*** empty log message ***

[SVN r11537]

algo_opt_examples.cpp

@@ -1,423 +0,0 @@
-
-/*
- *
- * Copyright (c) 1999
- * Dr John Maddock
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Dr John Maddock makes no representations
- * about the suitability of this software for any purpose.
- * It is provided "as is" without express or implied warranty.
- *
- * This file provides some example of type_traits usage -
- * by "optimising" various algorithms:
- *
- * opt::copy - optimised for trivial copy (cf std::copy)
- * opt::fill - optimised for trivial copy/small types (cf std::fill)
- * opt::destroy_array - an example of optimisation based upon omitted destructor calls
- * opt::iter_swap - uses type_traits to determine whether the iterator is a proxy
- *                  in which case it uses a "safe" approach, otherwise calls swap
- *                  on the assumption that swap may be specialised for the pointed-to type.
- *
- */
-
-/* Release notes:
-   23rd July 2000:
-      Added explicit failure for broken compilers that don't support these examples.
-      Fixed broken gcc support (broken using directive).
-      Reordered tests slightly.
-*/
-
-#include <iostream>
-#include <typeinfo>
-#include <algorithm>
-#include <iterator>
-#include <vector>
-#include <memory>
-
-#include <boost/timer.hpp>
-#include <boost/type_traits.hpp>
-#include <boost/call_traits.hpp>
-
-using std::cout;
-using std::endl;
-using std::cin;
-
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#error "Sorry, without template partial specialisation support there isn't anything to test here..."
-#endif
-
-namespace opt{
-
-//
-// algorithm destroy_arry:
-// The reverse of std::unitialized_copy, takes a block of
-// unitialized memory and calls destructors on all objects therein.
-//
-
-namespace detail{
-
-template <bool>
-struct array_destroyer
-{
-   template <class T>
-   static void destroy_array(T* i, T* j){ do_destroy_array(i, j); }
-};
-
-template <>
-struct array_destroyer<true>
-{
-   template <class T>
-   static void destroy_array(T*, T*){}
-};
-
-template <class T>
-void do_destroy_array(T* first, T* last)
-{
-   while(first != last)
-   {
-      first->~T();
-      ++first;
-   }
-}
-
-}; // namespace detail
-
-template <class T>
-inline void destroy_array(T* p1, T* p2)
-{
-   detail::array_destroyer<boost::has_trivial_destructor<T>::value>::destroy_array(p1, p2);
-}
-
-//
-// unoptimised versions of destroy_array:
-//
-template <class T>
-void destroy_array1(T* first, T* last)
-{
-   while(first != last)
-   {
-      first->~T();
-      ++first;
-   }
-}
-template <class T>
-void destroy_array2(T* first, T* last)
-{
-   for(; first != last; ++first) first->~T();
-}
-
-
-//
-// opt::copy
-// same semantics as std::copy
-// calls memcpy where appropiate.
-//
-
-namespace detail{
-
-template <bool b>
-struct copier
-{
-   template<typename I1, typename I2>
-   static I2 do_copy(I1 first, I1 last, I2 out);
-};
-
-template <bool b>
-template<typename I1, typename I2>
-I2 copier<b>::do_copy(I1 first, I1 last, I2 out)
-{
-   while(first != last)
-   {
-      *out = *first;
-      ++out;
-      ++first;
-   }
-   return out;
-}
-
-template <>
-struct copier<true>
-{
-   template<typename I1, typename I2>
-   static I2* do_copy(I1* first, I1* last, I2* out)
-   {
-      memcpy(out, first, (last-first)*sizeof(I2));
-      return out+(last-first);
-   }
-};
-
-
-}
-
-template<typename I1, typename I2>
-inline I2 copy(I1 first, I1 last, I2 out)
-{
-   typedef typename boost::remove_cv<typename std::iterator_traits<I1>::value_type>::type v1_t;
-   typedef typename boost::remove_cv<typename std::iterator_traits<I2>::value_type>::type v2_t;
-   enum{ can_opt = boost::is_same<v1_t, v2_t>::value
-                   && boost::is_pointer<I1>::value
-                   && boost::is_pointer<I2>::value
-                   && boost::has_trivial_assign<v1_t>::value };
-   return detail::copier<can_opt>::do_copy(first, last, out);
-}
-
-//
-// fill
-// same as std::fill, uses memset where appropriate, along with call_traits
-// to "optimise" parameter passing.
-//
-namespace detail{
-
-template <bool opt>
-struct filler
-{
-   template <typename I, typename T>
-   static void do_fill(I first, I last, typename boost::call_traits<T>::param_type val);
- };
-
-template <bool b>
-template <typename I, typename T>
-void filler<b>::do_fill(I first, I last, typename boost::call_traits<T>::param_type val)
-{
-   while(first != last)
-   {
-      *first = val;
-      ++first;
-   }
-}
-
-template <>
-struct filler<true>
-{
-   template <typename I, typename T>
-   static void do_fill(I first, I last, T val)
-   {
-      memset(first, val, last-first);
-   }
-};
-
-}
-
-template <class I, class T>
-inline void fill(I first, I last, const T& val)
-{
-   enum{ can_opt = boost::is_pointer<I>::value
-                   && boost::is_arithmetic<T>::value
-                   && (sizeof(T) == 1) };
-   typedef detail::filler<can_opt> filler_t;
-   filler_t::template do_fill<I,T>(first, last, val);
-}
-
-//
-// iter_swap:
-// tests whether iterator is a proxying iterator or not, and
-// uses optimal form accordingly:
-//
-namespace detail{
-
-template <bool b>
-struct swapper
-{
-   template <typename I>
-   static void do_swap(I one, I two)
-   {
-      typedef typename std::iterator_traits<I>::value_type v_t;
-      v_t v = *one;
-      *one = *two;
-      *two = v;
-   }
-};
-
-#ifdef __GNUC__
-using std::swap;
-#endif
-
-template <>
-struct swapper<true>
-{
-   template <typename I>
-   static void do_swap(I one, I two)
-   {
-      using std::swap;
-      swap(*one, *two);
-   }
-};
-
-}
-
-template <typename I1, typename I2>
-inline void iter_swap(I1 one, I2 two)
-{
-   typedef typename std::iterator_traits<I1>::reference r1_t;
-   typedef typename std::iterator_traits<I2>::reference r2_t;
-   enum{ can_opt = boost::is_reference<r1_t>::value && boost::is_reference<r2_t>::value && boost::is_same<r1_t, r2_t>::value };
-   detail::swapper<can_opt>::do_swap(one, two);
-}
-
-
-};   // namespace opt
-
-//
-// define some global data:
-//
-const int array_size = 1000;
-int i_array[array_size] = {0,};
-const int ci_array[array_size] = {0,};
-char c_array[array_size] = {0,};
-const char cc_array[array_size] = { 0,};
-
-const int iter_count = 1000000;
-
-
-int main()
-{
-   //
-   // test destroy_array,
-   // compare destruction time of an array of ints
-   // with unoptimised form.
-   //
-   cout << "Measuring times in micro-seconds per 1000 elements processed" << endl << endl;
-   cout << "testing destroy_array...\n"
-    "[Some compilers may be able to optimise the \"unoptimised\"\n versions as well as type_traits does.]" << endl;
-   /*cache load*/ opt::destroy_array(i_array, i_array + array_size);
-   boost::timer t;
-   double result;
-   int i;
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::destroy_array(i_array, i_array + array_size);
-   }
-   result = t.elapsed();
-   cout << "destroy_array<int>: " << result << endl;
-   /*cache load*/ opt::destroy_array1(i_array, i_array + array_size);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::destroy_array1(i_array, i_array + array_size);
-   }
-   result = t.elapsed();
-   cout << "destroy_array<int>(unoptimised#1): " << result << endl;
-   /*cache load*/ opt::destroy_array2(i_array, i_array + array_size);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::destroy_array2(i_array, i_array + array_size);
-   }
-   result = t.elapsed();
-   cout << "destroy_array<int>(unoptimised#2): " << result << endl << endl;
-
-   cout << "testing fill(char)...\n"
-   "[Some standard library versions may already perform this optimisation.]" << endl;
-   /*cache load*/ opt::fill<char*, char>(c_array, c_array + array_size, (char)3);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::fill<char*, char>(c_array, c_array + array_size, (char)3);
-   }
-   result = t.elapsed();
-   cout << "opt::fill<char*, char>: " << result << endl;
-   /*cache load*/ std::fill(c_array, c_array + array_size, (char)3);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      std::fill(c_array, c_array + array_size, (char)3);
-   }
-   result = t.elapsed();
-   cout << "std::fill<char*, char>: " << result << endl << endl;
-
-   cout << "testing fill(int)...\n"
-   "[Tests the effect of call_traits pass-by-value optimisation -\nthe value of this optimisation may depend upon hardware characteristics.]" << endl;
-   /*cache load*/ opt::fill<int*, int>(i_array, i_array + array_size, 3);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::fill<int*, int>(i_array, i_array + array_size, 3);
-   }
-   result = t.elapsed();
-   cout << "opt::fill<int*, int>: " << result << endl;
-   /*cache load*/ std::fill(i_array, i_array + array_size, 3);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      std::fill(i_array, i_array + array_size, 3);
-   }
-   result = t.elapsed();
-   cout << "std::fill<int*, int>: " << result << endl << endl;
-
-   cout << "testing copy...\n"
-   "[Some standard library versions may already perform this optimisation.]" << endl;
-   /*cache load*/ opt::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
-   }
-   result = t.elapsed();
-   cout << "opt::copy<const int*, int*>: " << result << endl;
-   /*cache load*/ std::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      std::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
-   }
-   result = t.elapsed();
-   cout << "std::copy<const int*, int*>: " << result << endl;
-   /*cache load*/ opt::detail::copier<false>::template do_copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::detail::copier<false>::template do_copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
-   }
-   result = t.elapsed();
-   cout << "standard \"unoptimised\" copy: " << result << endl << endl;
-
-   /*cache load*/ opt::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
-   }
-   result = t.elapsed();
-   cout << "opt::copy<const char*, char*>: " << result << endl;
-   /*cache load*/ std::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      std::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
-   }
-   result = t.elapsed();
-   cout << "std::copy<const char*, char*>: " << result << endl;
-   /*cache load*/ opt::detail::copier<false>::template do_copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::detail::copier<false>::template do_copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
-   }
-   result = t.elapsed();
-   cout << "standard \"unoptimised\" copy: " << result << endl << endl;
-
-
-   //
-   // testing iter_swap
-   // really just a check that it does in fact compile...
-   std::vector<int> v1;
-   v1.push_back(0);
-   v1.push_back(1);
-   std::vector<bool> v2;
-   v2.push_back(0);
-   v2.push_back(1);
-   opt::iter_swap(v1.begin(), v1.begin()+1);
-   opt::iter_swap(v2.begin(), v2.begin()+1);
-
-   cout << "Press any key to exit...";
-   cin.get();
-}
-
-
-
-
-

call_traits_test.cpp

@@ -1,368 +0,0 @@
-
-#include <cassert>
-#include <iostream>
-#include <iomanip>
-#include <algorithm>
-#include <typeinfo>
-#include <boost/call_traits.hpp>
-
-#ifdef __BORLANDC__
-// turn off some warnings, the way we do the tests will generate a *lot* of these
-// this is a result of the tests not call_traits itself....
-#pragma option -w-8004 -w-ccc -w-rch -w-eff -w-aus
-#endif
-
-//
-// struct contained models a type that contains a type (for example std::pair)
-// arrays are contained by value, and have to be treated as a special case:
-//
-template <class T>
-struct contained
-{
-   // define our typedefs first, arrays are stored by value
-   // so value_type is not the same as result_type:
-   typedef typename boost::call_traits<T>::param_type       param_type;
-   typedef typename boost::call_traits<T>::reference        reference;
-   typedef typename boost::call_traits<T>::const_reference  const_reference;
-   typedef T                                                value_type;
-   typedef typename boost::call_traits<T>::value_type       result_type;
-
-   // stored value:
-   value_type v_;
-   
-   // constructors:
-   contained() {}
-   contained(param_type p) : v_(p){}
-   // return byval:
-   result_type value()const { return v_; }
-   // return by_ref:
-   reference get() { return v_; }
-   const_reference const_get()const { return v_; }
-   // pass value:
-   void call(param_type p){}
-
-};
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T, std::size_t N>
-struct contained<T[N]>
-{
-   typedef typename boost::call_traits<T[N]>::param_type       param_type;
-   typedef typename boost::call_traits<T[N]>::reference        reference;
-   typedef typename boost::call_traits<T[N]>::const_reference  const_reference;
-   typedef T                                                   value_type[N];
-   typedef typename boost::call_traits<T[N]>::value_type       result_type;
-
-   value_type v_;
-
-   contained(param_type p)
-   {
-      std::copy(p, p+N, v_);
-   }
-   // return byval:
-   result_type value()const { return v_; }
-   // return by_ref:
-   reference get() { return v_; }
-   const_reference const_get()const { return v_; }
-   void call(param_type p){}
-};
-#endif
-
-template <class T>
-contained<typename boost::call_traits<T>::value_type> wrap(const T& t)
-{
-   typedef typename boost::call_traits<T>::value_type ct;
-   return contained<ct>(t);
-}
-
-namespace test{
-
-template <class T1, class T2>
-std::pair<
-   typename boost::call_traits<T1>::value_type,
-   typename boost::call_traits<T2>::value_type>
-      make_pair(const T1& t1, const T2& t2)
-{
-   return std::pair<
-      typename boost::call_traits<T1>::value_type,
-      typename boost::call_traits<T2>::value_type>(t1, t2);
-}
-
-} // namespace test
-
-using namespace std;
-
-//
-// struct checker:
-// verifies behaviour of contained example:
-//
-template <class T>
-struct checker
-{
-   typedef typename boost::call_traits<T>::param_type param_type;
-   void operator()(param_type);
-};
-
-template <class T>
-void checker<T>::operator()(param_type p)
-{
-   T t(p);
-   contained<T> c(t);
-   cout << "checking contained<" << typeid(T).name() << ">..." << endl;
-   assert(t == c.value());
-   assert(t == c.get());
-   assert(t == c.const_get());
-
-   cout << "typeof contained<" << typeid(T).name() << ">::v_ is:           " << typeid(&contained<T>::v_).name() << endl;
-   cout << "typeof contained<" << typeid(T).name() << ">::value() is:      " << typeid(&contained<T>::value).name() << endl;
-   cout << "typeof contained<" << typeid(T).name() << ">::get() is:        " << typeid(&contained<T>::get).name() << endl;
-   cout << "typeof contained<" << typeid(T).name() << ">::const_get() is:  " << typeid(&contained<T>::const_get).name() << endl;
-   cout << "typeof contained<" << typeid(T).name() << ">::call() is:       " << typeid(&contained<T>::call).name() << endl;
-   cout << endl;
-}
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T, std::size_t N>
-struct checker<T[N]>
-{
-   typedef typename boost::call_traits<T[N]>::param_type param_type;
-   void operator()(param_type t)
-   {
-      contained<T[N]> c(t);
-      cout << "checking contained<" << typeid(T[N]).name() << ">..." << endl;
-      unsigned int i = 0;
-      for(i = 0; i < N; ++i)
-         assert(t[i] == c.value()[i]);
-      for(i = 0; i < N; ++i)
-         assert(t[i] == c.get()[i]);
-      for(i = 0; i < N; ++i)
-         assert(t[i] == c.const_get()[i]);
-
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::v_ is:         " << typeid(&contained<T[N]>::v_).name() << endl;
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::value is:      " << typeid(&contained<T[N]>::value).name() << endl;
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::get is:        " << typeid(&contained<T[N]>::get).name() << endl;
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::const_get is:  " << typeid(&contained<T[N]>::const_get).name() << endl;
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::call is:       " << typeid(&contained<T[N]>::call).name() << endl;
-      cout << endl;
-   }
-};
-#endif
-
-//
-// check_wrap:
-template <class T, class U>
-void check_wrap(const contained<T>& w, const U& u)
-{
-   cout << "checking contained<" << typeid(T).name() << ">..." << endl;
-   assert(w.value() == u);
-}
-
-//
-// check_make_pair:
-// verifies behaviour of "make_pair":
-//
-template <class T, class U, class V>
-void check_make_pair(T c, U u, V v)
-{
-   cout << "checking std::pair<" << typeid(c.first).name() << ", " << typeid(c.second).name() << ">..." << endl;
-   assert(c.first == u);
-   assert(c.second == v);
-   cout << endl;
-}
-
-
-struct UDT
-{
-   int i_;
-   UDT() : i_(2){}
-   bool operator == (const UDT& v){ return v.i_ == i_; }
-};
-
-//
-// define tests here
-unsigned failures = 0;
-unsigned test_count = 0;
-
-#define value_test(v, x) ++test_count;\
-                         if(v != x){++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;}
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#define type_test(v, x)  ++test_count;\
-                           if(boost::is_same<v, x>::value == false){\
-                           ++failures; \
-                           std::cout << "checking type of " << #x << "...failed" << std::endl; \
-                           std::cout << "   expected type was " << #v << std::endl; \
-                           std::cout << "   " << typeid(boost::is_same<v, x>).name() << "::value is false" << std::endl; }
-#else
-#define type_test(v, x)  ++test_count;\
-                         if(typeid(v) != typeid(x)){\
-                           ++failures; \
-                           std::cout << "checking type of " << #x << "...failed" << std::endl; \
-                           std::cout << "   expected type was " << #v << std::endl; \
-                           std::cout << "   " << "typeid(" #v ") != typeid(" #x ")" << std::endl; }
-#endif
-
-int main()
-{
-   checker<UDT> c1;
-   UDT u;
-   c1(u);
-   checker<int> c2;
-   int i = 2;
-   c2(i);
-   int* pi = &i;
-   checker<int*> c3;
-   c3(pi);
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   checker<int&> c4;
-   c4(i);
-   checker<const int&> c5;
-   c5(i);
-
-   int a[2] = {1,2};
-   checker<int[2]> c6;
-   c6(a);
-#endif
-
-   check_wrap(wrap(2), 2);
-   const char ca[4] = "abc";
-   // compiler can't deduce this for some reason:
-   //check_wrap(wrap(ca), ca);
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   check_wrap(wrap(a), a);
-   check_make_pair(test::make_pair(a, a), a, a);
-#endif
-
-   // cv-qualifiers applied to reference types should have no effect
-   // declare these here for later use with is_reference and remove_reference:
-   typedef int& r_type;
-   typedef const r_type cr_type;
-
-   type_test(UDT, boost::call_traits<UDT>::value_type)
-   type_test(UDT&, boost::call_traits<UDT>::reference)
-   type_test(const UDT&, boost::call_traits<UDT>::const_reference)
-   type_test(const UDT&, boost::call_traits<UDT>::param_type)
-   type_test(int, boost::call_traits<int>::value_type)
-   type_test(int&, boost::call_traits<int>::reference)
-   type_test(const int&, boost::call_traits<int>::const_reference)
-   type_test(const int, boost::call_traits<int>::param_type)
-   type_test(int*, boost::call_traits<int*>::value_type)
-   type_test(int*&, boost::call_traits<int*>::reference)
-   type_test(int*const&, boost::call_traits<int*>::const_reference)
-   type_test(int*const, boost::call_traits<int*>::param_type)
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   type_test(int&, boost::call_traits<int&>::value_type)
-   type_test(int&, boost::call_traits<int&>::reference)
-   type_test(const int&, boost::call_traits<int&>::const_reference)
-   type_test(int&, boost::call_traits<int&>::param_type)
-#if !(defined(__GNUC__) && (__GNUC__ < 3))
-   type_test(int&, boost::call_traits<cr_type>::value_type)
-   type_test(int&, boost::call_traits<cr_type>::reference)
-   type_test(const int&, boost::call_traits<cr_type>::const_reference)
-   type_test(int&, boost::call_traits<cr_type>::param_type)
-#else
-   std::cout << "GNU C++ cannot instantiate call_traits<cr_type>, skipping four tests (4 errors)" << std::endl;
-   failures += 4;
-   test_count += 4;
-#endif
-   type_test(const int&, boost::call_traits<const int&>::value_type)
-   type_test(const int&, boost::call_traits<const int&>::reference)
-   type_test(const int&, boost::call_traits<const int&>::const_reference)
-   type_test(const int&, boost::call_traits<const int&>::param_type)
-   type_test(const int*, boost::call_traits<int[3]>::value_type)
-   type_test(int(&)[3], boost::call_traits<int[3]>::reference)
-   type_test(const int(&)[3], boost::call_traits<int[3]>::const_reference)
-   type_test(const int*const, boost::call_traits<int[3]>::param_type)
-   type_test(const int*, boost::call_traits<const int[3]>::value_type)
-   type_test(const int(&)[3], boost::call_traits<const int[3]>::reference)
-   type_test(const int(&)[3], boost::call_traits<const int[3]>::const_reference)
-   type_test(const int*const, boost::call_traits<const int[3]>::param_type)
-#else
-   std::cout << "You're compiler does not support partial template instantiation, skipping 20 tests (20 errors)" << std::endl;
-   failures += 20;
-   test_count += 20;
-#endif
-
-   std::cout << std::endl << test_count << " tests completed (" << failures << " failures)... press any key to exit";
-   std::cin.get();
-   return failures;
-}
-
-//
-// define call_traits tests to check that the assertions in the docs do actually work
-// this is an instantiate only set of tests:
-//
-template <typename T, bool isarray = false>
-struct call_traits_test
-{
-   static void assert_construct(boost::call_traits<T>::param_type val);
-};
-
-template <typename T, bool isarray>
-void call_traits_test<T, isarray>::assert_construct(boost::call_traits<T>::param_type val)
-{
-   //
-   // this is to check that the call_traits assertions are valid:
-   T t(val);
-   boost::call_traits<T>::value_type v(t);
-   boost::call_traits<T>::reference r(t);
-   boost::call_traits<T>::const_reference cr(t);
-   boost::call_traits<T>::param_type p(t);
-   boost::call_traits<T>::value_type v2(v);
-   boost::call_traits<T>::value_type v3(r);
-   boost::call_traits<T>::value_type v4(p);
-   boost::call_traits<T>::reference r2(v);
-   boost::call_traits<T>::reference r3(r);
-   boost::call_traits<T>::const_reference cr2(v);
-   boost::call_traits<T>::const_reference cr3(r);
-   boost::call_traits<T>::const_reference cr4(cr);
-   boost::call_traits<T>::const_reference cr5(p);
-   boost::call_traits<T>::param_type p2(v);
-   boost::call_traits<T>::param_type p3(r);
-   boost::call_traits<T>::param_type p4(p);
-}
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <typename T>
-struct call_traits_test<T, true>
-{
-   static void assert_construct(boost::call_traits<T>::param_type val);
-};
-
-template <typename T>
-void call_traits_test<T, true>::assert_construct(boost::call_traits<T>::param_type val)
-{
-   //
-   // this is to check that the call_traits assertions are valid:
-   T t;
-   boost::call_traits<T>::value_type v(t);
-   boost::call_traits<T>::value_type v5(val);
-   boost::call_traits<T>::reference r = t;
-   boost::call_traits<T>::const_reference cr = t;
-   boost::call_traits<T>::reference r2 = r;
-   #ifndef __BORLANDC__
-   // C++ Builder buglet:
-   boost::call_traits<T>::const_reference cr2 = r;
-   #endif
-   boost::call_traits<T>::param_type p(t);
-   boost::call_traits<T>::value_type v2(v);
-   boost::call_traits<T>::const_reference cr3 = cr;
-   boost::call_traits<T>::value_type v3(r);
-   boost::call_traits<T>::value_type v4(p);
-   boost::call_traits<T>::param_type p2(v);
-   boost::call_traits<T>::param_type p3(r);
-   boost::call_traits<T>::param_type p4(p);
-}
-#endif //BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-//
-// now check call_traits assertions by instantiating call_traits_test:
-template struct call_traits_test<int>;
-template struct call_traits_test<const int>;
-template struct call_traits_test<int*>;
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template struct call_traits_test<int&>;
-template struct call_traits_test<const int&>;
-template struct call_traits_test<int[2], true>;
-#endif
-
-

cast_test.cpp

@@ -1,149 +0,0 @@
-//  boost utility cast test program  -----------------------------------------//
-
-//  (C) Copyright boost.org 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
-//   28 Jun 00  implicit_cast removed (Beman Dawes)
-//   30 Aug 99  value_cast replaced by numeric_cast
-//    3 Aug 99  Initial Version
-
-#include <iostream>
-#include <climits>
-#include <limits>
-#include <boost/cast.hpp>
-
-#  if SCHAR_MAX == LONG_MAX
-#      error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
-#  endif 
-
-using namespace boost;
-using std::cout;
-
-namespace
-{
-    struct Base
-    { 
-        virtual char kind() { return 'B'; }
-    };
-    
-    struct Base2
-    { 
-        virtual char kind2() { return '2'; }
-    };
-    
-    struct Derived : public Base, Base2
-    {
-        virtual char kind() { return 'D'; }
-    }; 
-}   
-
-
-int main( int argc, char * argv[] )
-{
-    cout << "Usage: test_casts [n], where n omitted or is:\n"
-            "  1 = execute #1 assert failure (#ifndef NDEBUG)\n"
-            "  2 = execute #2 assert failure (#ifndef NDEBUG)\n"
-            "Example: test_casts 2\n\n";
-
-#   ifdef NDEBUG
-        cout << "NDEBUG is defined\n";
-#   else
-        cout << "NDEBUG is not defined\n";
-#   endif
-
-    cout << "\nBeginning tests...\n";        
-
-//  test polymorphic_cast  ---------------------------------------------------//
-    
-    //  tests which should succeed
-    Base *    base = new Derived;
-    Base2 *   base2 = 0;
-    Derived * derived = 0;
-    derived = polymorphic_downcast<Derived*>( base );  // downcast
-    assert( derived->kind() == 'D' );
-
-    derived = 0;
-    derived = polymorphic_cast<Derived*>( base ); // downcast, throw on error
-    assert( derived->kind() == 'D' );
-
-    base2 = polymorphic_cast<Base2*>( base ); // crosscast
-    assert( base2->kind2() == '2' );
-
-     //  tests which should result in errors being detected
-    int err_count = 0;
-    base = new Base;
-
-    if ( argc > 1 && *argv[1] == '1' )
-        { derived = polymorphic_downcast<Derived*>( base ); } // #1 assert failure
-
-    bool caught_exception = false;
-    try { derived = polymorphic_cast<Derived*>( base ); }
-    catch (std::bad_cast)
-        { cout<<"caught bad_cast\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-    //  the following is just so generated code can be inspected
-    if ( derived->kind() == 'B' ) ++err_count;
-
-//  test implicit_cast and numeric_cast  -------------------------------------//
-    
-    //  tests which should succeed
-    long small_value = 1;
-    long small_negative_value = -1;
-    long large_value = std::numeric_limits<long>::max();
-    long large_negative_value = std::numeric_limits<long>::min();
-    signed char c = 0;
-
-    c = large_value;  // see if compiler generates warning
-
-    c = numeric_cast<signed char>( small_value );
-    assert( c == 1 );
-    c = 0;
-    c = numeric_cast<signed char>( small_value );
-    assert( c == 1 );
-    c = 0;
-    c = numeric_cast<signed char>( small_negative_value );
-    assert( c == -1 );
-
-    //  tests which should result in errors being detected
-
-    caught_exception = false;
-    try { c = numeric_cast<signed char>( large_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #1\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    caught_exception = false;
-    try { c = numeric_cast<signed char>( large_negative_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #2\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    unsigned long ul;
-    caught_exception = false;
-    try { ul = numeric_cast<unsigned long>( large_negative_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #3\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    caught_exception = false;
-    try { ul = numeric_cast<unsigned long>( small_negative_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #4\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    caught_exception = false;
-    try { numeric_cast<int>( std::numeric_limits<double>::max() ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #5\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    cout << err_count << " errors detected\nTest "
-         << (err_count==0 ? "passed\n" : "failed\n");
-    return err_count;
-}   // main

include/boost/call_traits.hpp

@@ -1,23 +0,0 @@
-//  (C) Copyright Boost.org 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 boost/detail/call_traits.hpp and boost/detail/ob_call_traits.hpp
-//  for full copyright notices.
-
-#ifndef BOOST_CALL_TRAITS_HPP
-#define BOOST_CALL_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/detail/ob_call_traits.hpp>
-#else
-#include <boost/detail/call_traits.hpp>
-#endif
-
-#endif // BOOST_CALL_TRAITS_HPP

include/boost/compressed_pair.hpp

@@ -1,23 +0,0 @@
-//  (C) Copyright Boost.org 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 boost/detail/compressed_pair.hpp and boost/detail/ob_compressed_pair.hpp
-//  for full copyright notices.
-
-#ifndef BOOST_COMPRESSED_PAIR_HPP
-#define BOOST_COMPRESSED_PAIR_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/detail/ob_compressed_pair.hpp>
-#else
-#include <boost/detail/compressed_pair.hpp>
-#endif
-
-#endif // BOOST_COMPRESSED_PAIR_HPP

include/boost/detail/call_traits.hpp

@@ -1,135 +0,0 @@
-//  (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.
-
-/* Release notes:
-   23rd July 2000:
-      Fixed array specialization. (JM)
-      Added Borland specific fixes for reference types
-      (issue raised by Steve Cleary).
-*/
-
-#ifndef BOOST_DETAIL_CALL_TRAITS_HPP
-#define BOOST_DETAIL_CALL_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#ifndef BOOST_TYPE_TRAITS_HPP
-#include <boost/type_traits.hpp>
-#endif
-
-namespace boost{
-
-namespace detail{
-
-template <typename T, bool isp, bool b1, bool b2>
-struct ct_imp
-{
-   typedef const T& param_type;
-};
-
-template <typename T, bool isp>
-struct ct_imp<T, isp, true, true>
-{
-   typedef T const param_type;
-};
-
-template <typename T, bool b1, bool b2>
-struct ct_imp<T, true, b1, b2>
-{
-   typedef T const param_type;
-};
-
-}
-
-template <typename T>
-struct call_traits
-{
-public:
-   typedef T value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   //
-   // C++ Builder workaround: we should be able to define a compile time
-   // constant and pass that as a single template parameter to ct_imp<T,bool>,
-   // however compiler bugs prevent this - instead pass three bool's to
-   // ct_imp<T,bool,bool,bool> and add an extra partial specialisation
-   // of ct_imp to handle the logic. (JM)
-   typedef typename detail::ct_imp<T, ::boost::is_pointer<typename remove_const<T>::type>::value, ::boost::is_arithmetic<typename remove_const<T>::type>::value, sizeof(T) <= sizeof(void*)>::param_type param_type;
-};
-
-template <typename T>
-struct call_traits<T&>
-{
-   typedef T& value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef T& param_type;  // hh removed const
-};
-
-#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x550)
-// these are illegal specialisations; cv-qualifies applied to
-// references have no effect according to [8.3.2p1],
-// C++ Builder requires them though as it treats cv-qualified
-// references as distinct types...
-template <typename T>
-struct call_traits<T&const>
-{
-   typedef T& value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef T& param_type;  // hh removed const
-};
-template <typename T>
-struct call_traits<T&volatile>
-{
-   typedef T& value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef T& param_type;  // hh removed const
-};
-template <typename T>
-struct call_traits<T&const volatile>
-{
-   typedef T& value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef T& param_type;  // hh removed const
-};
-#endif
-
-template <typename T, std::size_t N>
-struct call_traits<T [N]>
-{
-private:
-   typedef T array_type[N];
-public:
-   // degrades array to pointer:
-   typedef const T* value_type;
-   typedef array_type& reference;
-   typedef const array_type& const_reference;
-   typedef const T* const param_type;
-};
-
-template <typename T, std::size_t N>
-struct call_traits<const T [N]>
-{
-private:
-   typedef const T array_type[N];
-public:
-   // degrades array to pointer:
-   typedef const T* value_type;
-   typedef array_type& reference;
-   typedef const array_type& const_reference;
-   typedef const T* const param_type;
-};
-
-}
-
-#endif // BOOST_DETAIL_CALL_TRAITS_HPP

include/boost/detail/compressed_pair.hpp

@@ -1,420 +0,0 @@
-//  (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.
-
-//
-// JM changes 25 Jan 2000:
-// Removed default arguments from compressed_pair_switch to get
-// C++ Builder 4 to accept them
-// rewriten swap to get gcc and C++ builder to compile.
-// added partial specialisations for case T1 == T2 to avoid duplicate constructor defs.
-
-#ifndef BOOST_DETAIL_COMPRESSED_PAIR_HPP
-#define BOOST_DETAIL_COMPRESSED_PAIR_HPP
-
-#include <algorithm>
-#ifndef BOOST_TYPE_TRAITS_HPP
-#include <boost/type_traits.hpp>
-#endif
-#ifndef BOOST_CALL_TRAITS_HPP
-#include <boost/call_traits.hpp>
-#endif
-
-namespace boost
-{
-
-// compressed_pair
-
-namespace details
-{
-   // JM altered 26 Jan 2000:
-   template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty>
-   struct compressed_pair_switch;
-
-   template <class T1, class T2>
-   struct compressed_pair_switch<T1, T2, false, false, false>
-      {static const int value = 0;};
-
-   template <class T1, class T2>
-   struct compressed_pair_switch<T1, T2, false, true, true>
-      {static const int value = 3;};
-
-   template <class T1, class T2>
-   struct compressed_pair_switch<T1, T2, false, true, false>
-      {static const int value = 1;};
-
-   template <class T1, class T2>
-   struct compressed_pair_switch<T1, T2, false, false, true>
-      {static const int value = 2;};
-
-   template <class T1, class T2>
-   struct compressed_pair_switch<T1, T2, true, true, true>
-      {static const int value = 4;};
-
-   template <class T1, class T2>
-   struct compressed_pair_switch<T1, T2, true, false, false>
-      {static const int value = 5;};
-
-   template <class T1, class T2, int Version> class compressed_pair_imp;
-
-#ifdef __GNUC__
-   // workaround for GCC (JM):
-   using std::swap;
-#endif
-   //
-   // can't call unqualified swap from within classname::swap
-   // as Koenig lookup rules will find only the classname::swap
-   // member function not the global declaration, so use cp_swap
-   // as a forwarding function (JM):
-   template <typename T>
-   inline void cp_swap(T& t1, T& t2)
-   {
-      using std::swap;
-      swap(t1, t2);
-   }
-
-   // 0    derive from neither
-
-   template <class T1, class T2>
-   class compressed_pair_imp<T1, T2, 0>
-   {
-   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_imp() {} 
-
-      compressed_pair_imp(first_param_type x, second_param_type y)
-         : first_(x), second_(y) {}
-
-      explicit compressed_pair_imp(first_param_type x)
-         : first_(x) {}
-
-      explicit compressed_pair_imp(second_param_type y)
-         : 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_imp& y)
-      {
-         cp_swap(first_, y.first_);
-         cp_swap(second_, y.second_);
-      }
-   private:
-      first_type first_;
-      second_type second_;
-   };
-
-   // 1    derive from T1
-
-   template <class T1, class T2>
-   class compressed_pair_imp<T1, T2, 1>
-      : private 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_imp() {}
-
-      compressed_pair_imp(first_param_type x, second_param_type y)
-         : first_type(x), second_(y) {}
-
-      explicit compressed_pair_imp(first_param_type x)
-         : first_type(x) {}
-
-      explicit compressed_pair_imp(second_param_type y)
-         : second_(y) {}
-
-      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_imp& y)
-      {
-         // no need to swap empty base class:
-         cp_swap(second_, y.second_);
-      }
-   private:
-      second_type second_;
-   };
-
-   // 2    derive from T2
-
-   template <class T1, class T2>
-   class compressed_pair_imp<T1, T2, 2>
-      : private 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_imp() {}
-
-      compressed_pair_imp(first_param_type x, second_param_type y)
-         : second_type(y), first_(x) {}
-
-      explicit compressed_pair_imp(first_param_type x)
-         : first_(x) {}
-
-      explicit compressed_pair_imp(second_param_type y)
-         : second_type(y) {}
-
-      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_imp& y)
-      {
-         // no need to swap empty base class:
-         cp_swap(first_, y.first_);
-      }
-
-   private:
-      first_type first_;
-   };
-
-   // 3    derive from T1 and T2
-
-   template <class T1, class T2>
-   class compressed_pair_imp<T1, T2, 3>
-      : private T1,
-        private 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_imp() {}
-
-      compressed_pair_imp(first_param_type x, second_param_type y)
-         : first_type(x), second_type(y) {}
-
-      explicit compressed_pair_imp(first_param_type x)
-         : first_type(x) {}
-
-      explicit compressed_pair_imp(second_param_type y)
-         : second_type(y) {}
-
-      first_reference       first()       {return *this;}
-      first_const_reference first() const {return *this;}
-
-      second_reference       second()       {return *this;}
-      second_const_reference second() const {return *this;}
-      //
-      // no need to swap empty bases:
-      void swap(compressed_pair_imp&) {}
-   };
-
-   // JM
-   // 4    T1 == T2, T1 and T2 both empty
-   //      Note does not actually store an instance of T2 at all -
-   //      but reuses T1 base class for both first() and second().
-   template <class T1, class T2>
-   class compressed_pair_imp<T1, T2, 4>
-      : private 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_imp() {}
-
-      compressed_pair_imp(first_param_type x, second_param_type)
-         : first_type(x) {}
-
-      explicit compressed_pair_imp(first_param_type x)
-         : first_type(x) {}
-
-      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_imp&) {}
-   private:
-   };
-
-   // 5    T1 == T2 and are not empty:   //JM
-
-   template <class T1, class T2>
-   class compressed_pair_imp<T1, T2, 5>
-   {
-   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_imp() {}
-
-      compressed_pair_imp(first_param_type x, second_param_type y)
-         : first_(x), second_(y) {}
-
-      explicit compressed_pair_imp(first_param_type x)
-         : first_(x), second_(x) {}
-
-      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_imp<T1, T2, 5>& y)
-      {
-         cp_swap(first_, y.first_);
-         cp_swap(second_, y.second_);
-      }
-   private:
-      first_type first_;
-      second_type second_;
-   };
-
-}  // details
-
-template <class T1, class T2>
-class compressed_pair
-   : private ::boost::details::compressed_pair_imp<T1, T2,
-             ::boost::details::compressed_pair_switch<
-                    T1,
-                    T2,
-                    ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
-                    ::boost::is_empty<T1>::value,
-                    ::boost::is_empty<T2>::value>::value>
-{
-private:
-   typedef details::compressed_pair_imp<T1, T2,
-             ::boost::details::compressed_pair_switch<
-                    T1,
-                    T2,
-                    ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
-                    ::boost::is_empty<T1>::value,
-                    ::boost::is_empty<T2>::value>::value> base;
-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() {}
-            compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
-   explicit compressed_pair(first_param_type x) : base(x) {}
-   explicit compressed_pair(second_param_type y) : base(y) {}
-
-   first_reference       first()       {return base::first();}
-   first_const_reference first() const {return base::first();}
-
-   second_reference       second()       {return base::second();}
-   second_const_reference second() const {return base::second();}
-
-   void swap(compressed_pair& y) { base::swap(y); }
-};
-
-// JM
-// Partial specialisation for case where T1 == T2:
-//
-template <class T>
-class compressed_pair<T, T>
-   : private details::compressed_pair_imp<T, T,
-             ::boost::details::compressed_pair_switch<
-                    T,
-                    T,
-                    ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
-                    ::boost::is_empty<T>::value,
-                    ::boost::is_empty<T>::value>::value>
-{
-private:
-   typedef details::compressed_pair_imp<T, T,
-             ::boost::details::compressed_pair_switch<
-                    T,
-                    T,
-                    ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
-                    ::boost::is_empty<T>::value,
-                    ::boost::is_empty<T>::value>::value> base;
-public:
-   typedef T                                                  first_type;
-   typedef T                                                  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() {}
-            compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
-   explicit compressed_pair(first_param_type x) : base(x) {}
-
-   first_reference       first()       {return base::first();}
-   first_const_reference first() const {return base::first();}
-
-   second_reference       second()       {return base::second();}
-   second_const_reference second() const {return base::second();}
-
-   void swap(compressed_pair& y) { base::swap(y); }
-};
-
-template <class T1, class T2>
-inline
-void
-swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
-{
-   x.swap(y);
-}
-
-} // boost
-
-#endif // BOOST_DETAIL_COMPRESSED_PAIR_HPP
-
-

include/boost/detail/ob_call_traits.hpp

@@ -1,35 +0,0 @@
-//  (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.
-//
-//  Crippled version for crippled compilers:
-//
-#ifndef BOOST_OB_CALL_TRAITS_HPP
-#define BOOST_OB_CALL_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#ifndef BOOST_TYPE_TRAITS_HPP
-#include <boost/type_traits.hpp>
-#endif
-
-namespace boost{
-
-template <typename T>
-struct call_traits
-{
-   typedef T value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef const T& param_type;
-};
-
-}
-
-#endif // BOOST_OB_CALL_TRAITS_HPP

include/boost/detail/ob_compressed_pair.hpp

@@ -1,77 +0,0 @@
-//  (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.
-//
-/* Release notes:
-   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_TYPE_TRAITS_HPP
-#include <boost/type_traits.hpp>
-#endif
-#ifndef BOOST_CALL_TRAITS_HPP
-#include <boost/call_traits.hpp>
-#endif
-
-namespace boost
-{
-
-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);
-}
-
-} // boost
-
-#endif // BOOST_OB_COMPRESSED_PAIR_HPP
-

include/boost/operators.hpp

@@ -1,559 +0,0 @@
-//  Boost operators.hpp header file  ----------------------------------------//
-
-//  (C) Copyright David Abrahams 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.
-
-//  (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
-//  04 Jul 00 Fixed NO_OPERATORS_IN_NAMESPACE bugs, major cleanup and
-//            refactoring of compiler workarounds, additional documentation
-//            (Alexy Gurtovoy and Mark Rodgers with some help and prompting from
-//            Dave Abrahams) 
-//  28 Jun 00 General cleanup and integration of bugfixes from Mark Rodgers and
-//            Jeremy Siek (Dave Abrahams)
-//  20 Jun 00 Changes to accommodate Borland C++Builder 4 and Borland C++ 5.5
-//            (Mark Rodgers)
-//  20 Jun 00 Minor fixes to the prior revision (Aleksey Gurtovoy)
-//  10 Jun 00 Support for the base class chaining technique was added
-//            (Aleksey Gurtovoy). See documentation and the comments below 
-//            for the details. 
-//  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
-//  18 Nov 99 Change name "divideable" to "dividable", remove unnecessary
-//            specializations of dividable, subtractable, modable (Ed Brey) 
-//  17 Nov 99 Add comments (Beman Dawes)
-//            Remove unnecessary specialization of operators<> (Ed Brey)
-//  15 Nov 99 Fix less_than_comparable<T,U> second operand type for first two
-//            operators.(Beman Dawes)
-//  12 Nov 99 Add operators templates (Ed Brey)
-//  11 Nov 99 Add single template parameter version for compilers without
-//            partial specialization (Beman Dawes)
-//  10 Nov 99 Initial version
-
-// 10 Jun 00:
-// An additional optional template parameter was added to most of 
-// operator templates to support the base class chaining technique (see 
-// documentation for the details). Unfortunately, a straightforward
-// implementation of this change would have broken compatibility with the
-// previous version of the library by making it impossible to use the same
-// template name (e.g. 'addable') for both the 1- and 2-argument versions of
-// an operator template. This implementation solves the backward-compatibility
-// issue at the cost of some simplicity.
-//
-// One of the complications is an existence of special auxiliary class template
-// 'is_chained_base<>' (see 'detail' namespace below), which is used
-// to determine whether its template parameter is a library's operator template
-// or not. You have to specialize 'is_chained_base<>' for each new 
-// operator template you add to the library.
-//
-// However, most of the non-trivial implementation details are hidden behind 
-// several local macros defined below, and as soon as you understand them,
-// you understand the whole library implementation. 
-
-#ifndef BOOST_OPERATORS_HPP
-#define BOOST_OPERATORS_HPP
-
-#include <boost/config.hpp>
-#include <boost/iterator.hpp>
-
-#if defined(__sgi) && !defined(__GNUC__)
-#pragma set woff 1234
-#endif
-
-namespace boost {
-namespace detail {
-
-class empty_base {};
-
-} // namespace detail
-} // namespace boost
-
-// In this section we supply the xxxx1 and xxxx2 forms of the operator
-// templates, which are explicitly targeted at the 1-type-argument and
-// 2-type-argument operator forms, respectively. Some compilers get confused
-// when inline friend functions are overloaded in namespaces other than the
-// global namespace. When BOOST_NO_OPERATORS_IN_NAMESPACE is defined, all of
-// these templates must go in the global namespace.
-
-#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
-namespace boost
-{
-#endif
-
-//  Basic operator classes (contributed by Dave Abrahams) ------------------//
-
-//  Note that friend functions defined in a class are implicitly inline.
-//  See the C++ std, 11.4 [class.friend] paragraph 5
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct less_than_comparable2 : B
-{
-     friend bool operator<=(const T& x, const U& y) { return !(x > y); }
-     friend bool operator>=(const T& x, const U& y) { return !(x < y); }
-     friend bool operator>(const U& x, const T& y)  { return y < x; }
-     friend bool operator<(const U& x, const T& y)  { return y > x; }
-     friend bool operator<=(const U& x, const T& y) { return !(y < x); }
-     friend bool operator>=(const U& x, const T& y) { return !(y > x); }
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct less_than_comparable1 : B
-{
-     friend bool operator>(const T& x, const T& y)  { return y < x; }
-     friend bool operator<=(const T& x, const T& y) { return !(y < x); }
-     friend bool operator>=(const T& x, const T& y) { return !(x < y); }
-};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct equality_comparable2 : B
-{
-     friend bool operator==(const U& y, const T& x) { return x == y; }
-     friend bool operator!=(const U& y, const T& x) { return !(x == y); }
-     friend bool operator!=(const T& y, const U& x) { return !(y == x); }
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct equality_comparable1 : B
-{
-     friend bool operator!=(const T& x, const T& y) { return !(x == y); }
-};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct multipliable2 : B
-{
-     friend T operator*(T x, const U& y) { return x *= y; }
-     friend T operator*(const U& y, T x) { return x *= y; }
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct multipliable1 : B
-{
-     friend T operator*(T x, const T& y) { return x *= y; }
-};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct addable2 : B
-{
-     friend T operator+(T x, const U& y) { return x += y; }
-     friend T operator+(const U& y, T x) { return x += y; }
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct addable1 : B
-{
-     friend T operator+(T x, const T& y) { return x += y; }
-};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct subtractable2 : B
-{
-     friend T operator-(T x, const U& y) { return x -= y; }
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct subtractable1 : B
-{
-     friend T operator-(T x, const T& y) { return x -= y; }
-};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct dividable2 : B
-{
-     friend T operator/(T x, const U& y) { return x /= y; }
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct dividable1 : B
-{
-     friend T operator/(T x, const T& y) { return x /= y; }
-};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct modable2 : B
-{
-     friend T operator%(T x, const U& y) { return x %= y; }
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct modable1 : B
-{
-     friend T operator%(T x, const T& y) { return x %= y; }
-};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct xorable2 : B
-{
-     friend T operator^(T x, const U& y) { return x ^= y; }
-     friend T operator^(const U& y, T x) { return x ^= y; }
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct xorable1 : B
-{
-     friend T operator^(T x, const T& y) { return x ^= y; }
-};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct andable2 : B
-{
-     friend T operator&(T x, const U& y) { return x &= y; }
-     friend T operator&(const U& y, T x) { return x &= y; }
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct andable1 : B
-{
-     friend T operator&(T x, const T& y) { return x &= y; }
-};
-
-template <class T, class U, class B = ::boost::detail::empty_base>
-struct orable2 : B
-{
-     friend T operator|(T x, const U& y) { return x |= y; }
-     friend T operator|(const U& y, T x) { return x |= y; }
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct orable1 : B
-{
-     friend T operator|(T x, const T& y) { return x |= y; }
-};
-
-//  incrementable and decrementable contributed by Jeremy Siek
-
-template <class T, class B = ::boost::detail::empty_base>
-struct incrementable : B
-{
-  friend T operator++(T& x, int)
-  {
-    incrementable_type tmp(x);
-    ++x;
-    return tmp;
-  }
-private: // The use of this typedef works around a Borland bug
-  typedef T incrementable_type;
-};
-
-template <class T, class B = ::boost::detail::empty_base>
-struct decrementable : B
-{
-  friend T operator--(T& x, int)
-  {
-    decrementable_type tmp(x);
-    --x;
-    return tmp;
-  }
-private: // The use of this typedef works around a Borland bug
-  typedef T decrementable_type;
-};
-
-//  Iterator operator classes (contributed by Jeremy Siek) ------------------//
-
-template <class T, class P, class B = ::boost::detail::empty_base>
-struct dereferenceable : B
-{
-  P operator->() const
-  { 
-    return &*static_cast<const T&>(*this); 
-  }
-};
-
-template <class T, class I, class R, class B = ::boost::detail::empty_base>
-struct indexable : B
-{
-  R operator[](I n) const
-  {
-    return *(static_cast<const T&>(*this) + n);
-  }
-};
-
-#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
-} // namespace boost
-#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
-
-
-// BOOST_IMPORT_TEMPLATE1/BOOST_IMPORT_TEMPLATE2 -
-//
-// When BOOST_NO_OPERATORS_IN_NAMESPACE is defined we need a way to import an
-// operator template into the boost namespace. BOOST_IMPORT_TEMPLATE1 is used
-// for one-argument forms of operator templates; BOOST_IMPORT_TEMPLATE2 for
-// two-argument forms. Note that these macros expect to be invoked from within
-// boost.
-
-#if defined(BOOST_NO_OPERATORS_IN_NAMESPACE)
-
-#  if defined(BOOST_NO_USING_TEMPLATE)
-
-     // Because a Borland C++ 5.5 bug prevents a using declaration from working,
-     // we are forced to use inheritance for that compiler.
-#    define BOOST_IMPORT_TEMPLATE2(template_name)                              \
-     template <class T, class U, class B = ::boost::detail::empty_base>        \
-     struct template_name : ::template_name<T, U, B> {};
-
-#    define BOOST_IMPORT_TEMPLATE1(template_name)                              \
-     template <class T, class B = ::boost::detail::empty_base>                 \
-     struct template_name : ::template_name<T, B> {};
-
-#  else
-
-     // Otherwise, bring the names in with a using-declaration to avoid
-     // stressing the compiler
-#    define BOOST_IMPORT_TEMPLATE2(template_name) using ::template_name;
-#    define BOOST_IMPORT_TEMPLATE1(template_name) using ::template_name;
-
-#  endif // BOOST_NO_USING_TEMPLATE
-
-#else // !BOOST_NO_OPERATORS_IN_NAMESPACE
-
-  // The template is already in boost so we have nothing to do.
-# define BOOST_IMPORT_TEMPLATE2(template_name)
-# define BOOST_IMPORT_TEMPLATE1(template_name)
-
-#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
-
-//
-// Here's where we put it all together, defining the xxxx forms of the templates
-// in namespace boost. We also define specializations of is_chained_base<> for
-// the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as
-// neccessary.
-//
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-// is_chained_base<> - a traits class used to distinguish whether an operator
-// template argument is being used for base class chaining, or is specifying a
-// 2nd argument type.
-
-namespace boost {
-// A type parameter is used instead of a plain bool because Borland's compiler
-// didn't cope well with the more obvious non-type template parameter.
-namespace detail {
-  struct true_t {};
-  struct false_t {};
-} // namespace detail
-
-// Unspecialized version assumes that most types are not being used for base
-// class chaining. We specialize for the operator templates defined in this
-// library.
-template<class T> struct is_chained_base {
-  typedef ::boost::detail::false_t value;
-};
-
-} // namespace boost
-
-// Import a 2-type-argument operator template into boost (if neccessary) and
-// provide a specialization of 'is_chained_base<>' for it.
-# define BOOST_OPERATOR_TEMPLATE2(template_name2)                  \
-  BOOST_IMPORT_TEMPLATE2(template_name2)                           \
-  template<class T, class U, class B>                              \
-  struct is_chained_base< ::boost::template_name2<T, U, B> > {     \
-    typedef ::boost::detail::true_t value;                         \
-  };
-
-// Import a 1-type-argument operator template into boost (if neccessary) and
-// provide a specialization of 'is_chained_base<>' for it.
-# define BOOST_OPERATOR_TEMPLATE1(template_name1)                  \
-  BOOST_IMPORT_TEMPLATE1(template_name1)                           \
-  template<class T, class B>                                       \
-  struct is_chained_base< ::boost::template_name1<T, B> > {        \
-    typedef ::boost::detail::true_t value;                         \
-  };
-
-// BOOST_OPERATOR_TEMPLATE(template_name) defines template_name<> such that it
-// can be used for specifying both 1-argument and 2-argument forms. Requires the
-// existence of two previously defined class templates named '<template_name>1'
-// and '<template_name>2' which must implement the corresponding 1- and 2-
-// argument forms.
-//
-// The template type parameter O == is_chained_base<U>::value is used to
-// distinguish whether the 2nd argument to <template_name> is being used for
-// base class chaining from another boost operator template or is describing a
-// 2nd operand type. O == true_t only when U is actually an another operator
-// template from the library. Partial specialization is used to select an
-// implementation in terms of either '<template_name>1' or '<template_name>2'.
-//
-
-# define BOOST_OPERATOR_TEMPLATE(template_name)                    \
-template <class T                                                  \
-         ,class U = T                                              \
-         ,class B = ::boost::detail::empty_base                    \
-         ,class O = typename is_chained_base<U>::value             \
-         >                                                         \
-struct template_name : template_name##2<T, U, B> {};               \
-                                                                   \
-template<class T, class U, class B>                                \
-struct template_name<T, U, B, ::boost::detail::true_t>             \
-  : template_name##1<T, U> {};                                     \
-                                                                   \
-template <class T, class B>                                        \
-struct template_name<T, T, B, ::boost::detail::false_t>            \
-  : template_name##1<T, B> {};                                     \
-                                                                   \
-template<class T, class U, class B, class O>                       \
-struct is_chained_base< ::boost::template_name<T, U, B, O> > {     \
-  typedef ::boost::detail::true_t value;                           \
-};                                                                 \
-                                                                   \
-BOOST_OPERATOR_TEMPLATE2(template_name##2)                         \
-BOOST_OPERATOR_TEMPLATE1(template_name##1)
-
-
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#  define BOOST_OPERATOR_TEMPLATE2(template_name2) \
-        BOOST_IMPORT_TEMPLATE2(template_name2)
-#  define BOOST_OPERATOR_TEMPLATE1(template_name1) \
-        BOOST_IMPORT_TEMPLATE1(template_name1)
-
-   // In this case we can only assume that template_name<> is equivalent to the
-   // more commonly needed template_name1<> form.
-#  define BOOST_OPERATOR_TEMPLATE(template_name)                   \
-   template <class T, class B = ::boost::detail::empty_base>       \
-   struct template_name : template_name##1<T, B> {};
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-namespace boost {
-    
-BOOST_OPERATOR_TEMPLATE(less_than_comparable)
-BOOST_OPERATOR_TEMPLATE(equality_comparable)
-BOOST_OPERATOR_TEMPLATE(multipliable)
-BOOST_OPERATOR_TEMPLATE(addable)
-BOOST_OPERATOR_TEMPLATE(subtractable)
-BOOST_OPERATOR_TEMPLATE(dividable)
-BOOST_OPERATOR_TEMPLATE(modable)
-BOOST_OPERATOR_TEMPLATE(xorable)
-BOOST_OPERATOR_TEMPLATE(andable)
-BOOST_OPERATOR_TEMPLATE(orable)
-
-BOOST_OPERATOR_TEMPLATE1(incrementable)
-BOOST_OPERATOR_TEMPLATE1(decrementable)
-BOOST_OPERATOR_TEMPLATE2(dereferenceable)
-
-// indexable doesn't follow the patterns above (it has 4 template arguments), so
-// we just write out the compiler hacks explicitly.
-#ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
-# ifdef BOOST_NO_USING_TEMPLATE
-   template <class T, class I, class R, class B = ::boost::detail::empty_base>
-   struct indexable : ::indexable<T,I,R,B> {};
-# else
-   using ::indexable;
-# endif
-#endif
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T, class I, class R, class B>
-struct is_chained_base< ::boost::indexable<T, I, R, B> > {
-  typedef ::boost::detail::true_t operator_template_type;
-};
-#endif
-
-#undef BOOST_OPERATOR_TEMPLATE
-#undef BOOST_OPERATOR_TEMPLATE2
-#undef BOOST_OPERATOR_TEMPLATE1
-#undef BOOST_IMPORT_TEMPLATE1
-#undef BOOST_IMPORT_TEMPLATE2
-
-// The following 'operators' classes can only be used portably if the derived class
-// declares ALL of the required member operators.
-template <class T, class U>
-struct operators2
-    : less_than_comparable2<T,U
-    , equality_comparable2<T,U
-    , addable2<T,U
-    , subtractable2<T,U
-    , multipliable2<T,U
-    , dividable2<T,U
-    , modable2<T,U
-    , orable2<T,U
-    , andable2<T,U
-    , xorable2<T,U
-      > > > > > > > > > > {};
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T, class U = T>
-struct operators : operators2<T, U> {};
-
-template <class T> struct operators<T, T>
-#else
-template <class T> struct operators
-#endif
-    : less_than_comparable<T
-    , equality_comparable<T
-    , addable<T
-    , subtractable<T
-    , multipliable<T
-    , dividable<T
-    , modable<T
-    , orable<T
-    , andable<T
-    , xorable<T
-    , incrementable<T
-    , decrementable<T
-      > > > > > > > > > > > > {};
-
-//  Iterator helper classes (contributed by Jeremy Siek) -------------------//
-template <class T,
-          class V,
-          class D = std::ptrdiff_t,
-          class P = V*,
-          class R = V&>
-struct forward_iterator_helper
-  : equality_comparable<T
-  , incrementable<T
-  , dereferenceable<T,P
-  , boost::iterator<std::forward_iterator_tag, V, D
-    > > > > {};
-
-template <class T,
-          class V,
-          class D = std::ptrdiff_t,
-          class P = V*,
-          class R = V&>
-struct bidirectional_iterator_helper
-  : equality_comparable<T
-  , incrementable<T
-  , decrementable<T
-  , dereferenceable<T,P
-  , boost::iterator<std::bidirectional_iterator_tag, V, D
-    > > > > > {};
-
-template <class T,
-          class V, 
-          class D = std::ptrdiff_t,
-          class P = V*,
-          class R = V&>
-struct random_access_iterator_helper
-  : equality_comparable<T
-  , less_than_comparable<T
-  , incrementable<T
-  , decrementable<T
-  , dereferenceable<T,P
-  , addable2<T,D
-  , subtractable2<T,D
-  , indexable<T,D,R
-  , boost::iterator<std::random_access_iterator_tag, V, D
-    > > > > > > > > >
-{
-#ifndef __BORLANDC__
-  friend D requires_difference_operator(const T& x, const T& y) {
-    return x - y;
-  }
-#endif
-}; // random_access_iterator_helper
-
-} // namespace boost
-
-#if defined(__sgi) && !defined(__GNUC__)
-#pragma reset woff 1234
-#endif
-
-#endif // BOOST_OPERATORS_HPP

include/boost/utility.hpp

@@ -1,69 +0,0 @@
-//  boost utility.hpp header file  -------------------------------------------//
-
-//  (C) Copyright boost.org 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.
-
-//  Classes appear in alphabetical order
-
-//  Revision History
-//  26 Jan 00  protected noncopyable destructor added (Miki Jovanovic)
-//  10 Dec 99  next() and prior() templates added (Dave Abrahams)
-//  30 Aug 99  moved cast templates to cast.hpp (Beman Dawes)
-//   3 Aug 99  cast templates added
-//  20 Jul 99  name changed to utility.hpp 
-//   9 Jun 99  protected noncopyable default ctor
-//   2 Jun 99  Initial Version. Class noncopyable only contents (Dave Abrahams)
-
-#ifndef BOOST_UTILITY_HPP
-#define BOOST_UTILITY_HPP
-
-#include <boost/config.hpp>
-#include <cstddef>            // for size_t
-
-namespace boost
-{
-
-//  next() and prior() template functions  -----------------------------------//
-
-    //  Helper functions for classes like bidirectional iterators not supporting
-    //  operator+ and operator-.
-    //
-    //  Usage:
-    //    const std::list<T>::iterator p = get_some_iterator();
-    //    const std::list<T>::iterator prev = boost::prior(p);
-
-    //  Contributed by Dave Abrahams
-
-    template <class T>
-    T next(T x) { return ++x; }
-
-    template <class T>
-    T prior(T x) { return --x; }
-
-
-//  class noncopyable  -------------------------------------------------------//
-
-    //  Private copy constructor and copy assignment ensure classes derived from
-    //  class noncopyable cannot be copied.
-
-    //  Contributed by Dave Abrahams
-
-    class noncopyable
-    {
-    protected:
-        noncopyable(){}
-        ~noncopyable(){}
-    private:  // emphasize the following members are private
-        noncopyable( const noncopyable& );
-        const noncopyable& operator=( const noncopyable& );
-    }; // noncopyable
-
-} // namespace boost
-
-#endif  // BOOST_UTILITY_HPP
-

iterator_adaptor_test.cpp

@@ -0,0 +1,376 @@
+//  Test boost/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
+//  08 Mar 01 Moved indirect and transform tests to separate files.
+//            (Jeremy Siek)
+//  19 Feb 01 Take adavantage of improved iterator_traits to do more tests
+//            on MSVC. Hack around an MSVC-with-STLport internal compiler
+//            error. (David Abrahams)
+//  11 Feb 01 Added test of operator-> for forward and input iterators.
+//            (Jeremy Siek)
+//  11 Feb 01 Borland fixes (David Abrahams)
+//  10 Feb 01 Use new adaptors interface. (David Abrahams)
+//  10 Feb 01 Use new filter_ interface. (David Abrahams)
+//  09 Feb 01 Use new reverse_ and indirect_ interfaces. Replace
+//            BOOST_NO_STD_ITERATOR_TRAITS with
+//            BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION to prove we've
+//            normalized to core compiler capabilities (David Abrahams)
+//  08 Feb 01 Use Jeremy's new make_reverse_iterator form; add more
+//            comprehensive testing. Force-decay array function arguments to
+//            pointers.
+//  07 Feb 01 Added tests for the make_xxx_iterator() helper functions.
+//            (Jeremy Siek)
+//  07 Feb 01 Replaced use of xxx_pair_generator with xxx_generator where
+//            possible (which was all but the projection iterator).
+//            (Jeremy Siek)
+//  06 Feb 01 Removed now-defaulted template arguments where possible
+//            Updated names to correspond to new generator naming convention.
+//            Added a trivial test for make_transform_iterator().
+//            Gave traits for const iterators a mutable value_type, per std.
+//            Resurrected my original tests for indirect iterators.
+//            (David Abrahams)
+//  04 Feb 01 Fix for compilers without standard iterator_traits
+//            (David Abrahams)
+//  13 Jun 00 Added const version of the iterator tests (Jeremy Siek)
+//  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
+
+#include <boost/config.hpp>
+#include <iostream>
+
+#include <algorithm>
+#include <functional>
+
+#include <boost/iterator_adaptors.hpp>
+#include <boost/pending/iterator_tests.hpp>
+#include <boost/pending/integer_range.hpp>
+#include <boost/concept_archetype.hpp>
+#include <boost/type_traits/same_traits.hpp>
+#include <stdlib.h>
+#include <vector>
+#include <deque>
+#include <set>
+
+struct my_iterator_tag : public std::random_access_iterator_tag { };
+
+using boost::dummyT;
+
+
+struct mult_functor {
+  typedef int result_type;
+  typedef int argument_type;
+  // Functors used with transform_iterator must be
+  // DefaultConstructible, as the transform_iterator must be
+  // DefaultConstructible to satisfy the requirements for
+  // TrivialIterator.
+  mult_functor() { }
+  mult_functor(int aa) : a(aa) { }
+  int operator()(int b) const { return a * b; }
+  int a;
+};
+
+template <class Pair>
+struct select1st_ 
+  : public std::unary_function<Pair, typename Pair::first_type>
+{
+  const typename Pair::first_type& operator()(const Pair& x) const {
+    return x.first;
+  }
+  typename Pair::first_type& operator()(Pair& x) const {
+    return x.first;
+  }
+};
+
+struct one_or_four {
+  bool operator()(dummyT x) const {
+    return x.foo() == 1 || x.foo() == 4;
+  }
+};
+
+typedef std::deque<int> storage;
+typedef std::deque<int*> pointer_deque;
+typedef std::set<storage::iterator> iterator_set;
+
+template <class T> struct foo;
+
+int
+main()
+{
+  dummyT array[] = { dummyT(0), dummyT(1), dummyT(2), 
+                     dummyT(3), dummyT(4), dummyT(5) };
+  const int N = sizeof(array)/sizeof(dummyT);
+
+  // sanity check, if this doesn't pass the test is buggy
+  boost::random_access_iterator_test(array, N, array);
+
+#if 0
+  // Check that the policy concept checks and the default policy
+  // implementation match up.
+  boost::function_requires< 
+     boost::RandomAccessIteratorPoliciesConcept<
+       boost::default_iterator_policies,
+       boost::iterator_adaptor<int*, boost::default_iterator_policies>,
+       boost::iterator<std::random_access_iterator_tag, int, std::ptrdiff_t,
+                      int*, int&>
+      > >();
+
+  // Test the named parameters
+  {
+    // Test computation of defaults
+    typedef boost::iterator_adaptor<int*, boost::default_iterator_policies,
+      boost::value_type_is<int> > Iter1;
+    BOOST_STATIC_ASSERT((boost::is_same<std::iterator_traits<Iter1>::value_type, int>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<std::iterator_traits<Iter1>::reference, int&>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<std::iterator_traits<Iter1>::pointer, int*>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<std::iterator_traits<Iter1>::difference_type, std::ptrdiff_t>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<std::iterator_traits<Iter1>::iterator_category, std::random_access_iterator_tag>::value));
+  }
+  {  
+    // Test computation of default when the Value is const
+    typedef boost::iterator_adaptor<int*, boost::default_iterator_policies,
+      boost::value_type_is<const int> > Iter1;
+    BOOST_STATIC_ASSERT((boost::is_same<std::iterator_traits<Iter1>::value_type, int>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<std::iterator_traits<Iter1>::reference, const int&>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<std::iterator_traits<Iter1>::pointer, const int*>::value));
+  }
+  {
+    // Test with no defaults
+    typedef boost::iterator_adaptor<int*, boost::default_iterator_policies,
+      boost::reference_is<long>,
+      boost::pointer_is<float>,
+      boost::value_type_is<char>,
+      boost::iterator_category_is<std::input_iterator_tag>,
+      boost::difference_type_is<int>
+    > Iter1;
+    BOOST_STATIC_ASSERT((boost::is_same<std::iterator_traits<Iter1>::value_type, char>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<std::iterator_traits<Iter1>::reference, long>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<std::iterator_traits<Iter1>::pointer, float>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<std::iterator_traits<Iter1>::difference_type, int>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<std::iterator_traits<Iter1>::iterator_category, std::input_iterator_tag>::value));
+  }
+  
+  // Test the iterator_adaptor
+  {
+    boost::iterator_adaptor<dummyT*, boost::default_iterator_policies, dummyT> i(array);
+    boost::random_access_iterator_test(i, N, array);
+    
+    boost::iterator_adaptor<const dummyT*, boost::default_iterator_policies, const dummyT> j(array);
+    boost::random_access_iterator_test(j, N, array);
+    boost::const_nonconst_iterator_test(i, ++j);
+  }
+
+  // Test projection_iterator_pair_generator
+  {    
+    typedef std::pair<dummyT,dummyT> Pair;
+    Pair pair_array[N];
+    for (int k = 0; k < N; ++k)
+      pair_array[k].first = array[k];
+
+    typedef boost::projection_iterator_pair_generator<select1st_<Pair>,
+      Pair*, const Pair*
+      > Projection;
+    
+    Projection::iterator i(pair_array);
+    boost::random_access_iterator_test(i, N, array);
+
+    boost::random_access_iterator_test(boost::make_projection_iterator(pair_array, select1st_<Pair>()), N, array);    
+    boost::random_access_iterator_test(boost::make_projection_iterator< select1st_<Pair> >(pair_array), N, array);    
+
+    Projection::const_iterator j(pair_array);
+    boost::random_access_iterator_test(j, N, array);
+
+    boost::random_access_iterator_test(boost::make_const_projection_iterator(pair_array, select1st_<Pair>()), N, array);
+    boost::random_access_iterator_test(boost::make_const_projection_iterator<select1st_<Pair> >(pair_array), N, array);
+
+    boost::const_nonconst_iterator_test(i, ++j);
+  }
+
+  // Test reverse_iterator_generator
+  {
+    dummyT reversed[N];
+    std::copy(array, array + N, reversed);
+    std::reverse(reversed, reversed + N);
+    
+    typedef boost::reverse_iterator_generator<dummyT*
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , dummyT
+#endif
+      >::type reverse_iterator;
+    
+    reverse_iterator i(reversed + N);
+    boost::random_access_iterator_test(i, N, array);
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
+#endif
+
+    typedef boost::reverse_iterator_generator<const dummyT*
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+      , dummyT, const dummyT&, const dummyT
+#endif
+      >::type const_reverse_iterator;
+    
+    const_reverse_iterator j(reversed + N);
+    boost::random_access_iterator_test(j, N, array);
+
+    const dummyT* const_reversed = reversed;
+    
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
+#endif
+    
+    boost::const_nonconst_iterator_test(i, ++j);    
+  }
+
+  // Test reverse_iterator_generator again, with traits fully deducible on all platforms
+  {
+    std::deque<dummyT> reversed_container;
+    std::reverse_copy(array, array + N, std::back_inserter(reversed_container));
+    const std::deque<dummyT>::iterator reversed = reversed_container.begin();
+
+
+    typedef boost::reverse_iterator_generator<
+        std::deque<dummyT>::iterator>::type reverse_iterator;
+    typedef boost::reverse_iterator_generator<
+        std::deque<dummyT>::const_iterator, const dummyT>::type const_reverse_iterator;
+
+    // MSVC/STLport gives an INTERNAL COMPILER ERROR when any computation
+    // (e.g. "reversed + N") is used in the constructor below.
+    const std::deque<dummyT>::iterator finish = reversed_container.end();
+    reverse_iterator i(finish);
+    
+    boost::random_access_iterator_test(i, N, array);
+    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
+
+    const_reverse_iterator j = reverse_iterator(finish);
+    boost::random_access_iterator_test(j, N, array);
+
+    const std::deque<dummyT>::const_iterator const_reversed = reversed;
+    boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
+    
+    // Many compilers' builtin deque iterators don't interoperate well, though
+    // STLport fixes that problem.
+#if defined(__SGI_STL_PORT) || !defined(__GNUC__) && !defined(__BORLANDC__) && !defined(BOOST_MSVC)
+    boost::const_nonconst_iterator_test(i, ++j);
+#endif
+  }
+  
+  // Test integer_range's iterators
+  {
+    int int_array[] = { 0, 1, 2, 3, 4, 5 };
+    boost::integer_range<int> r(0, 5);
+    boost::random_access_iterator_test(r.begin(), r.size(), int_array);
+  }
+
+  // Test filter iterator
+  {
+    // Using typedefs for filter_gen::type confused Borland terribly.
+    typedef boost::detail::non_bidirectional_category<dummyT*>::type category;
+    
+    typedef boost::filter_iterator_generator<one_or_four, dummyT*
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , dummyT
+#endif
+        >::type filter_iter;
+
+#if defined(__BORLANDC__)
+    // Borland is choking on accessing the policies_type explicitly
+    // from the filter_iter. 
+    boost::forward_iterator_test(make_filter_iterator(array, array+N, 
+						      one_or_four()),
+				 dummyT(1), dummyT(4));
+#else
+    filter_iter i(array, filter_iter::policies_type(one_or_four(), array + N));
+    boost::forward_iterator_test(i, dummyT(1), dummyT(4));
+#endif
+
+#if !defined(__BORLANDC__)
+    // 
+    enum { is_forward = boost::is_same<
+           filter_iter::iterator_category,
+           std::forward_iterator_tag>::value };
+    BOOST_STATIC_ASSERT(is_forward);
+#endif
+
+    // On compilers not supporting partial specialization, we can do more type
+    // deduction with deque iterators than with pointers... unless the library
+    // is broken ;-(
+#if !defined(BOOST_MSVC) || defined(__SGI_STL_PORT)
+    std::deque<dummyT> array2;
+    std::copy(array+0, array+N, std::back_inserter(array2));
+    boost::forward_iterator_test(
+        boost::make_filter_iterator(array2.begin(), array2.end(), one_or_four()),
+        dummyT(1), dummyT(4));
+
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(array2.begin(), array2.end()),
+        dummyT(1), dummyT(4));
+#endif
+
+#if !defined(BOOST_MSVC) // This just freaks MSVC out completely
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(
+            boost::make_reverse_iterator(array2.end()),
+            boost::make_reverse_iterator(array2.begin())
+            ),
+        dummyT(4), dummyT(1));
+#endif
+    
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::forward_iterator_test(
+        boost::make_filter_iterator(array+0, array+N, one_or_four()),
+        dummyT(1), dummyT(4));
+
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(array, array + N),
+        dummyT(1), dummyT(4));
+
+#endif
+  }
+
+  // check operator-> with a forward iterator
+  {
+    boost::forward_iterator_archetype<dummyT> forward_iter;
+#if defined(__BORLANDC__)
+    typedef boost::iterator_adaptor<boost::forward_iterator_archetype<dummyT>,
+      boost::default_iterator_policies,
+      dummyT, const dummyT&, const dummyT*, 
+      std::forward_iterator_tag, std::ptrdiff_t> adaptor_type;
+#else
+    typedef boost::iterator_adaptor<boost::forward_iterator_archetype<dummyT>,
+      boost::default_iterator_policies,
+      boost::reference_is<const dummyT&>,
+      boost::pointer_is<const dummyT*> ,
+      boost::iterator_category_is<std::forward_iterator_tag>,
+      boost::value_type_is<dummyT>,
+      boost::difference_type_is<std::ptrdiff_t>
+    > adaptor_type;
+#endif
+    adaptor_type i(forward_iter);
+    int zero = 0;
+    if (zero) // don't do this, just make sure it compiles
+      assert((*i).m_x == i->foo());      
+  }
+  // check operator-> with an input iterator
+  {
+    boost::input_iterator_archetype<dummyT> input_iter;
+    typedef boost::iterator_adaptor<boost::input_iterator_archetype<dummyT>,
+      boost::default_iterator_policies,
+      dummyT, const dummyT&, const dummyT*, 
+      std::input_iterator_tag, std::ptrdiff_t> adaptor_type;
+    adaptor_type i(input_iter);
+    int zero = 0;
+    if (zero) // don't do this, just make sure it compiles
+      assert((*i).m_x == i->foo());      
+  }
+#endif
+  std::cout << "test successful " << std::endl;
+  return 0;
+}

iterator_adaptors.htm

@@ -0,0 +1,928 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//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>Boost Iterator Adaptor Library</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>Boost Iterator Adaptor Library</h1>
+
+    <h2>Introduction</h2>
+
+    <p>The Iterator Adaptor library allows you transform an arbitrary ``base''
+    type into a standard-conforming iterator with the behaviors you choose.
+    Doing so is especially easy if the ``base'' type is itself an iterator. The
+    library also supplies several example <a href=
+    "../../more/generic_programming.html#adaptors">adaptors</a> which apply
+    specific useful behaviors to arbitrary base iterators.
+
+    <h2>Backward Compatibility Note</h2>
+
+    <p>The library's interface has changed since it was first released, breaking
+    backward compatibility:
+
+    <ol>
+
+    <li><a href="#policies">Policies classes</a> now operate on instances of the
+    whole <tt>iterator_adaptor</tt> object, rather than just operating on the
+    <tt>Base</tt> object. This change not only gives the policies class access
+    to both members of a pair of interacting iterators, but also eliminates the
+    need for the ugly <tt>type&lt;Reference&gt;</tt> and
+    <tt>type&lt;Difference&gt;</tt> parameters to various policy functions.
+
+    <li>The <a href="#named_template_parameters">Named Template Parameter</a>
+    interface has been made simpler, easier to use, and compatible with more
+    compilers.
+
+    </ol>
+
+    <h2>Other Documentation</h2>
+
+    <p><a href="iterator_adaptors.pdf">``Policy Adaptors and the Boost Iterator
+    Adaptor Library''</a> is a technical paper describing this library and the
+    powerful design pattern on which it is based. It was presented at the <a
+    href="http://www.oonumerics.org/tmpw01">C++ Template Workshop</a> at OOPSLA
+    2001; the slides from the talk are available <a
+    href="iterator_adaptors.ppt">here</a>. Please note that while the slides
+    incorporate the minor interface changes described in the previous section,
+    the paper does not.
+
+    <h2>Table of Contents</h2>
+
+    <ul>
+      <li>
+        Header <tt><a href=
+        "../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a></tt>
+        
+
+        <ul>
+          <li>
+            Generalized Iterator Adaptor 
+
+            <ul>
+              <li>Class template <tt><a href=
+              "#iterator_adaptor">iterator_adaptor</a></tt>
+
+              <li><a href="#template_parameters">Template Parameters</a>
+
+              <li><a href="#named_template_parameters">Named Template Parameters</a>
+
+              <li><a href="#policies">The Policies Class</a>
+
+              <li><a href="#additional_members">Additional Class Members</a>
+
+              <li><a href="#example">Example</a>
+
+              <li>(<tt>const</tt>/non-<tt>const</tt>) <a href=
+              "#iterator_interactions">Iterator Interactions</a>
+
+              <li><a href="#challenge">Challenge</a>
+
+              <li><a href="#concept_model">Concept Model</a>
+
+              <li><a href="#declaration_synopsis">Declaration Synopsis</a>
+
+              <li><a href="#notes">Notes</a>
+            </ul>
+
+          <li>
+            <a name="specialized_adaptors">Specialized Iterator Adaptors</a> 
+
+            <ul>
+              <li><a href="indirect_iterator.htm">Indirect Iterator Adaptor</a>
+
+              <li><a href="reverse_iterator.htm">Reverse Iterator Adaptor</a>
+
+              <li><a href="transform_iterator.htm">Transform Iterator
+              Adaptor</a>
+
+              <li><a href="projection_iterator.htm">Projection Iterator
+              Adaptor</a>
+
+              <li><a href="filter_iterator.htm">Filter Iterator Adaptor</a>
+            </ul>
+        </ul>
+
+      <li>Header <tt><a href=
+      "../../boost/counting_iterator.hpp">boost/counting_iterator.hpp</a></tt><br>
+
+       <a href="counting_iterator.htm">Counting Iterator Adaptor</a>
+
+      <li>Header <tt><a href=
+      "../../boost/function_output_iterator.hpp">boost/function_output_iterator.hpp</a></tt><br>
+
+       <a href="function_output_iterator.htm">Function Output Iterator Adaptor</a>
+    </ul>
+
+    <p><b><a href="../../people/dave_abrahams.htm">Dave
+    Abrahams</a></b> started the library, applying <a href=
+    "../../more/generic_programming.html#policy">policy class</a> technique and
+    handling const/non-const iterator interactions. He also contributed the
+    <tt><a href="indirect_iterator.htm">indirect_</a></tt> and <tt><a href=
+    "reverse_iterator.htm">reverse_</a></tt> iterator generators, and expanded
+    <tt><a href="counting_iterator.htm">counting_iterator_generator</a></tt> to
+    cover all incrementable types. He edited most of the documentation,
+    sometimes heavily.<br>
+     <b><a href="../../people/jeremy_siek.htm">Jeremy
+    Siek</a></b> contributed the <a href="transform_iterator.htm">transform
+    iterator</a> adaptor, the integer-only version of <tt><a href=
+    "counting_iterator.htm">counting_iterator_generator</a></tt>, 
+    the <a href="function_output_iterator.htm">function output iterator</a> 
+    adaptor, and most of the documentation.<br>
+     <b><a href="http://www.boost.org/people/john_potter.htm">John
+    Potter</a></b> contributed the <tt><a href=
+    "projection_iterator.htm">projection_</a></tt> and <tt><a href=
+    "filter_iterator.htm">filter_</a></tt> iterator generators and made some
+    simplifications to the main <tt><a href=
+    "#iterator_adaptor">iterator_adaptor</a></tt> template.<br>
+
+
+    <h2><a name="iterator_adaptor">Class template</a>
+    <tt>iterator_adaptor</tt></h2>
+    Implementing standard conforming iterators is a non-trivial task. There are
+    some fine points such as the interactions between an iterator and its
+    corresponding const_iterator, and there are myriad operators that should be
+    implemented but are easily forgotten or mishandled, such as
+    <tt>operator-&gt;()</tt>. Using <tt>iterator_adaptor</tt>, you can easily
+    implement an iterator class, and even more easily extend and <a href=
+    "../../more/generic_programming.html#adaptors">adapt</a> existing iterator
+    types. Moreover, it is easy to make a pair of interoperable <tt>const</tt>
+    and <tt>non-const</tt> iterators. 
+
+    <p><tt>iterator_adaptor</tt> is declared like this:
+<pre>
+template &lt;class Base, class Policies, 
+    class ValueOrNamedParam = typename std::iterator_traits&lt;Base&gt;::value_type,
+    class ReferenceOrNamedParam = <i>...(see below)</i>,
+    class PointerOrNamedParam = <i>...(see below)</i>,
+    class CategoryOrNamedParam = typename std::iterator_traits&lt;Base&gt;::iterator_category,
+    class DistanceOrNamedParam = typename std::iterator_traits&lt;Base&gt;::difference_type&gt;
+struct iterator_adaptor;
+</pre>
+
+    <h3><a name="template_parameters">Template Parameters</a></h3>
+
+    <p>Although <tt>iterator_adaptor</tt> takes seven template parameters,
+    defaults have been carefully chosen to minimize the number of parameters
+    you must supply in most cases, especially if <tt>BaseType</tt> is an
+    iterator.
+
+    <table border="1" summary="iterator_adaptor template parameters">
+      <tr>
+        <th>Parameter
+
+        <th>Description
+
+      <tr>
+        <td><tt>BaseType</tt> 
+
+        <td>The type being wrapped.
+
+      <tr>
+        <td><tt>Policies</tt> 
+
+        <td>A <a href="../../more/generic_programming.html#policy">policy
+        class</a> that supplies core functionality to the resulting iterator. A
+        detailed description can be found <a href="#policies">below</a>.
+
+      <tr>
+        <td><tt>Value</tt> 
+
+        <td>The <tt>value_type</tt> of the resulting iterator, unless const. If
+        Value is <tt>const X</tt> the
+        <tt>value_type</tt> will be (<i>non-</i><tt>const</tt>) <tt>X</tt><a href=
+        "#1">[1]</a>. If the <tt>value_type</tt> you wish to use is an abstract
+        base class see note <a href="#5">[5]</a>.<br>
+         <b>Default:</b>
+        <tt>std::iterator_traits&lt;BaseType&gt;::value_type</tt> <a href=
+        "#2">[2]</a>
+
+      <tr>
+        <td><tt>Reference</tt> 
+
+        <td>The <tt>reference</tt> type of the resulting iterator, and in
+        particular, the result type of <tt>operator*()</tt>.<br>
+         <b>Default:</b> If <tt>Value</tt> is supplied, <tt>Value&amp;</tt> is
+        used. Otherwise
+        <tt>std::iterator_traits&lt;BaseType&gt;::reference</tt> is used. <a href="#7">[7]</a>
+
+      <tr>
+        <td><tt>Pointer</tt> 
+
+        <td>The <tt>pointer</tt> type of the resulting iterator, and in
+        particular, the result type of <tt>operator-&gt;()</tt>.<br>
+         <b>Default:</b> If <tt>Value</tt> was supplied, then <tt>Value*</tt>,
+        otherwise <tt>std::iterator_traits&lt;BaseType&gt;::pointer</tt>. <a href="#7">[7]</a>
+
+      <tr>
+        <td><tt>Category</tt> 
+
+        <td>The <tt>iterator_category</tt> type for the resulting iterator.<br>
+         <b>Default:</b>
+        <tt>std::iterator_traits&lt;BaseType&gt;::iterator_category</tt> 
+
+      <tr>
+        <td><tt>Distance</tt> 
+
+        <td>The <tt>difference_type</tt> for the resulting iterator.<br>
+         <b>Default:</b>
+        <tt>std::iterator_traits&lt;BaseType&gt;::difference_type</tt> 
+
+      <tr>
+         <td><tt>NamedParam</tt>
+
+         <td>A named template parameter (see below).
+    </table>
+
+    <h3><a name="named_template_parameters">Named Template Parameters</a></h3>
+    
+    With seven template parameters, providing arguments for
+    <tt>iterator_adaptor</tt> in the correct order can be challenging.
+    Also, often times one would like to specify the sixth or seventh
+    template parameter, but use the defaults for the third through
+    fifth. As a solution to these problems we provide a mechanism for
+    naming the last five template parameters, and providing them in
+    any order through a set of named template parameters. The following
+    classes are provided for specifying the parameters. Any of these
+    classes can be used for any of the last five template parameters
+    of <tt>iterator_adaptor</tt>.
+    <blockquote>
+<pre>
+template &lt;class Value&gt; struct value_type_is;
+template &lt;class Reference&gt; struct reference_is;
+template &lt;class Pointer&gt; struct pointer_is;
+template &lt;class Distance&gt; struct difference_type_is;
+template &lt;class Category&gt; struct iterator_category_is;
+</pre>
+    </blockquote>
+
+    For example, the following adapts <tt>foo_iterator</tt> to create
+    an <a href=
+    "http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>
+    with <tt>reference</tt> type <tt>foo</tt>, and whose other traits
+    are determined according to the defaults described <a
+    href="#template_parameters">above</a>.
+
+    <blockquote>
+<pre>
+typedef iterator_adaptor&lt;foo_iterator, foo_policies,
+  reference_is&lt;foo&gt;, iterator_category_is&lt;std::input_iterator_tag&gt;
+  &gt; MyIterator;
+</pre>
+    </blockquote>
+
+    
+    <h3><a name="policies">The Policies Class</a></h3>
+
+    <p>The main task in using <tt>iterator_adaptor</tt> is creating an
+    appropriate <tt>Policies</tt> class. The <tt>Policies</tt> class will become
+    the functional heart of the resulting iterator, supplying the core
+    operations that determine its behavior. The <tt>iterator_adaptor</tt>
+    template defines all of the operators required of a <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a> by dispatching to a <tt>Policies</tt> object. Your
+    <tt>Policies</tt> class must implement a subset of the core iterator
+    operations below corresponding to the iterator categories you want it to
+    support.<br>
+    <br>
+    
+
+    <table border="1" summary="iterator_adaptor Policies operations">
+      <caption>
+        <b>Core Iterator Operations</b><br>
+        <tt>T</tt>: adapted iterator type; <tt>p</tt>: object of type T; <tt>n</tt>: <tt>T::size_type</tt>; <tt>x</tt>: <tt>T::difference_type</tt>; <tt>p1</tt>, <tt>p2</tt>: iterators
+      </caption>
+
+      <tr>
+        <th>Operation
+
+        <th>Effects
+
+        <th>Implements Operations
+
+        <th>Required for Iterator Categories
+
+      <tr>
+        <td><tt>initialize</tt>
+
+        <td>optionally modify base iterator during iterator construction
+
+        <td>constructors
+
+        <td rowspan="4"><a href=
+        "http://www.sgi.com/tech/stl/InputIterator.html">Input</a>/ <a href=
+        "http://www.sgi.com/tech/stl/OutputIterator.html">Output</a>/ <a href=
+        "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward</a>/ <a
+        href=
+        "http://www.sgi.com/tech/stl/BidirectionalIterator.html">Bidirectional</a>/
+        <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+        Access</a> 
+
+	  
+      <tr>
+        <td><tt>dereference</tt> 
+
+        <td>returns an element of the iterator's <tt>reference</tt> type
+        
+        <td><tt>*p</tt>, <tt>p[n]</tt>
+
+
+      <tr>
+        <td><tt>equal</tt> 
+
+        <td>tests the iterator for equality
+
+        <td><tt>p1&nbsp;==&nbsp;p2</tt>, <tt>p1&nbsp;!=&nbsp;p2</tt>
+
+      <tr>
+        <td><tt>increment</tt> 
+
+        <td>increments the iterator
+
+        <td><tt>++p</tt>, <tt>p++</tt>
+
+      <tr>
+        <td><tt>decrement</tt> 
+
+        <td>decrements the iterator
+
+        <td><tt>--p</tt>, <tt>p--</tt>
+
+        <td><a href=
+        "http://www.sgi.com/tech/stl/BidirectionalIterator.html">Bidirectional</a>/
+        <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+        Access</a> 
+
+      <tr>
+        <td><tt>less</tt> 
+
+        <td>imposes a <a href=
+        "http://www.sgi.com/tech/stl/StrictWeakOrdering.html">Strict Weak
+        Ordering</a> relation on iterators
+
+        <td> 
+           <tt>p1&nbsp;&lt;&nbsp;p2</tt>,
+           <tt>p1&nbsp;&lt;=&nbsp;p2</tt>,
+           <tt>p1&nbsp;&gt;&nbsp;p2</tt>,
+           <tt>p1&nbsp;&gt;=&nbsp;p2</tt>
+
+        <td rowspan="3"><a href=
+        "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+        Access</a> 
+
+      <tr>
+        <td><tt>distance</tt> 
+
+        <td>measures the distance between iterators
+
+        <td><tt>p1 - p2</tt>
+
+      <tr>
+        <td><tt>advance</tt> 
+
+        <td>adds an integer offset to iterators
+
+        <td>
+<tt>p&nbsp;+&nbsp;x</tt>,
+<tt>x&nbsp;+&nbsp;p</tt>,
+<tt>p&nbsp;+=&nbsp;x</tt>,
+<tt>p&nbsp;-&nbsp;x</tt>,
+<tt>p&nbsp;-=&nbsp;x</tt>
+        
+    </table>
+
+    <p>The library also supplies a "trivial" policy class,
+    <tt>default_iterator_policies</tt>, which implements all seven of the core
+    operations in the usual way. If you wish to create an iterator adaptor that
+    only changes a few of the base type's behaviors, then you can derive your
+    new policy class from <tt>default_iterator_policies</tt> to avoid retyping
+    the usual behaviors. You should also look at
+    <tt>default_iterator_policies</tt> as the ``boilerplate'' for your own
+    policy classes, defining functions with the same interface. This is the
+    definition of <tt>default_iterator_policies</tt>:<br>
+    <br>
+
+    <blockquote>
+<pre>
+struct <a name="default_iterator_policies">default_iterator_policies</a>
+{
+    // Some of these members were defined static, but Borland got confused
+    // and thought they were non-const. Also, Sun C++ does not like static
+    // function templates.
+
+    template &lt;class Base&gt;
+    void initialize(Base&amp;)
+        { }
+
+    template &lt;class IteratorAdaptor&gt;
+    typename IteratorAdaptor::reference dereference(const IteratorAdaptor&amp; x) const
+        { return *x.base(); }
+
+    template &lt;class IteratorAdaptor&gt;
+    void increment(IteratorAdaptor&amp; x)
+        { ++x.base(); }
+
+    template &lt;class IteratorAdaptor&gt;
+    void decrement(IteratorAdaptor&amp; x)
+        { --x.base(); }
+
+    template &lt;class IteratorAdaptor, class DifferenceType&gt;
+    void advance(IteratorAdaptor&amp; x, DifferenceType n)
+        { x.base() += n; }
+
+    template &lt;class IteratorAdaptor1, class IteratorAdaptor2&gt;
+    typename IteratorAdaptor1::difference_type
+    distance(const IteratorAdaptor1&amp; x, const IteratorAdaptor2&amp; y) const
+        { return y.base() - x.base(); }
+
+    template &lt;class IteratorAdaptor1, class IteratorAdaptor2&gt;
+    bool equal(const IteratorAdaptor1&amp; x, const IteratorAdaptor2&amp; y) const
+        { return x.base() == y.base(); }
+};
+</pre></blockquote>
+
+    <p>Template member functions are used throughout
+    <tt>default_iterator_policies</tt> so that it can be employed with a wide
+    range of iterators. If we had used concrete types above, we'd have tied the
+    usefulness of <tt>default_iterator_policies</tt> to a particular range of
+    adapted iterators. If you follow the same pattern with your
+    <tt>Policies</tt> classes, you can use them to generate more specialized
+    adaptors along the lines of <a href="#specialized_adaptors">those supplied by this library</a>.
+
+    <h3><a name="additional_members">Additional Members</a></h3>
+    In addition to all of the member functions required of a <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a>, the <tt>iterator_adaptor</tt> class template defines the
+    following members. <br>
+     <br>
+     
+
+    <table border="1" summary="additional iterator_adaptor members">
+      <tr>
+        <td><tt>explicit iterator_adaptor(const Base&amp;, const Policies&amp; =
+        Policies())</tt>
+         <br><br>
+         Construct an adapted iterator from a base object and a policies
+         object. As this constructor is <tt>explicit</tt>, it does not
+         provide for implicit conversions from the <tt>Base</tt> type to
+         the iterator adaptor.
+
+      <tr>
+        <td><tt>template &lt;class B, class V, class R, class P&gt;<br>
+         iterator_adaptor(const
+        iterator_adaptor&lt;B,Policies,V,R,P,Category,Distance&gt;&amp;)</tt>
+        <br><br>
+         This constructor allows for conversion from mutable to
+        constant adapted iterators. See <a href=
+        "#iterator_interactions">below</a> for more details.<br>
+         Requires: <tt>B</tt> is convertible to <tt>Base</tt>.
+
+      <tr>
+        <td><tt>base_type base() const;</tt>
+         <br><br>
+         Return a copy of the base object.
+    </table>
+
+    <h3><a name="example">Example</a></h3>
+
+    <p>It is often useful to automatically apply some function to the value
+    returned by dereferencing an iterator. The <a href=
+    "./transform_iterator.htm">transform iterator</a> makes it easy to create
+    an iterator adaptor which does just that. Here we will show how easy it is
+    to implement the transform iterator using the <tt>iterator_adaptor</tt>
+    template.
+
+    <p>We want to be able to adapt a range of iterators and functions, so the
+    policies class will have a template parameter for the function type and it
+    will have a data member of that type. We know that the function takes one
+    argument and that we'll need to be able to deduce the <tt>result_type</tt>
+    of the function so we can use it for the adapted iterator's
+    <tt>value_type</tt>. <a href=
+    "http://www.sgi.com/Technology/STL/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>
+    is the <a href="../../more/generic_programming.html#concept">Concept</a>
+    that fulfills those requirements.
+
+    <p>To implement a transform iterator we will only change one of the base
+    iterator's behaviors, so the <tt>transform_iterator_policies</tt> class can
+    inherit the rest from <tt>default_iterator_policies</tt>. We will define the
+    <tt>dereference()</tt> member function, which is used to implement
+    <tt>operator*()</tt> of the adapted iterator. The implementation will
+    dereference the base iterator and apply the function object. The complete
+    code for <tt>transform_iterator_policies</tt> is:<br>
+    <br>
+
+<blockquote><pre>
+template &lt;class AdaptableUnaryFunction&gt;
+struct transform_iterator_policies : public default_iterator_policies
+{
+    transform_iterator_policies() { }
+
+    transform_iterator_policies(const AdaptableUnaryFunction&amp; f)
+        : m_f(f) { }
+    
+    template &lt;class IteratorAdaptor&gt;
+    typename IteratorAdaptor::reference
+    dereference(const IteratorAdaptor&amp; iter) const
+        { return m_f(*iter.base()); }
+
+    AdaptableUnaryFunction m_f;
+};
+
+</pre></blockquote>
+
+    <p>The next step is to use the <tt>iterator_adaptor</tt> template to
+    construct the transform iterator type. The nicest way to package the
+    construction of the transform iterator is to create a <a href=
+    "../../more/generic_programming.html#type_generator">type generator</a>.
+    The first template parameter to the generator will be the type of the
+    function object and the second will be the base iterator type. We use
+    <tt>iterator_adaptor</tt> to define the transform iterator type as a nested
+    <tt>typedef</tt> inside the <tt>transform_iterator_generator</tt> class.
+    Because the function may return by-value, we must limit the
+    <tt>iterator_category</tt> to <a href=
+    "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>, and
+    the iterator's <tt>reference</tt> type cannot be a true reference (the
+    standard allows this for input iterators), so in this case we can use few
+    of <tt>iterator_adaptor</tt>'s default template arguments.<br>
+    <br>
+
+
+    <blockquote>
+<pre>
+template &lt;class AdaptableUnaryFunction, class Iterator&gt;
+struct transform_iterator_generator
+{
+    typedef typename AdaptableUnaryFunction::result_type value_type;
+public:
+    typedef iterator_adaptor&lt;Iterator, 
+        transform_iterator_policies&lt;AdaptableUnaryFunction&gt;,
+        value_type, value_type, value_type*, std::input_iterator_tag&gt;
+      type;
+};
+</pre>
+    </blockquote>
+
+    <p>As a finishing touch, we will create an <a href=
+    "../../more/generic_programming.html#object_generator">object generator</a>
+    for the transform iterator. Our object generator makes it more
+    convenient to create a transform iterator.<br>
+    <br>
+
+
+    <blockquote>
+<pre>
+template &lt;class AdaptableUnaryFunction, class Iterator&gt;
+typename transform_iterator_generator&lt;AdaptableUnaryFunction,Iterator&gt;::type
+make_transform_iterator(Iterator base,
+                        const AdaptableUnaryFunction&amp; f = AdaptableUnaryFunction())
+{
+    typedef typename transform_iterator_generator&lt;AdaptableUnaryFunction,
+      Iterator&gt;::type result_t;
+    return result_t(base, f);
+}
+</pre>
+    </blockquote>
+
+    <p>Here is an example that shows how to use a transform iterator to iterate
+    through a range of numbers, multiplying each of them by 2 and printing the
+    result to standard output.<br>
+    <br>
+
+
+    <blockquote>
+<pre>
+#include &lt;functional&gt;
+#include &lt;algorithm&gt;
+#include &lt;iostream&gt;
+#include &lt;boost/iterator_adaptors.hpp&gt;
+
+int main(int, char*[])
+{
+  int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+  const int N = sizeof(x)/sizeof(int);
+  std::cout &lt;&lt; &quot;multiplying the array by 2:&quot; &lt;&lt; std::endl;
+  std::copy(boost::make_transform_iterator(x, std::bind1st(std::multiplies&lt;int&gt;(), 2)),
+      boost::make_transform_iterator(x + N, std::bind1st(std::multiplies&lt;int&gt;(), 2)),
+      std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
+  std::cout &lt;&lt; std::endl;
+  return 0;
+}
+</pre>
+      This output is: 
+<pre>
+2 4 6 8 10 12 14 16
+</pre>
+    </blockquote>
+
+    <h3><a name="iterator_interactions">Iterator Interactions</a></h3>
+
+    <p>C++ allows <tt>const</tt> and non-<tt>const</tt> pointers to interact in
+    the following intuitive ways:
+
+    <ul>
+      <li>a non-<tt>const</tt> pointer to <tt>T</tt> can be implicitly
+      converted to a <tt>const</tt> pointer to <tt>T</tt>.
+
+      <li><tt>const</tt> and non-<tt>const</tt> pointers to <tt>T</tt> can be
+      freely mixed in comparison expressions.
+
+      <li><tt>const</tt> and non-<tt>const</tt> pointers to <tt>T</tt> can be
+      freely subtracted, in any order.
+    </ul>
+
+    Getting user-defined iterators to work together that way is nontrivial (see
+    <a href="reverse_iterator.htm#interactions">here</a> for an example of where
+    the C++ standard got it wrong), but <tt>iterator_adaptor</tt> can make it
+    easy. The rules are as follows:
+
+    <ul>
+      <li><a name="interoperable">Adapted iterators that share the same <tt>Policies</tt>,
+      <tt>Category</tt>, and <tt>Distance</tt> parameters are called
+      <i>interoperable</i>.</a>
+
+      <li>An adapted iterator can be implicitly converted to any other adapted
+      iterator with which it is interoperable, so long as the <tt>Base</tt>
+      type of the source iterator can be converted to the <tt>Base</tt> type of
+      the target iterator.
+
+      <li>Interoperable iterators can be freely mixed in comparison expressions
+      so long as the <tt>Policies</tt> class has <tt>equal</tt> (and, for
+      random access iterators, <tt>less</tt>) members that can accept both
+      <tt>Base</tt> types in either order.
+
+      <li>Interoperable iterators can be freely mixed in subtraction
+      expressions so long as the <tt>Policies</tt> class has a
+      <tt>distance</tt> member that can accept both <tt>Base</tt> types in
+      either order.
+    </ul>
+
+    <h4>Example</h4>
+    
+    <p>The <a href="projection_iterator.htm">Projection Iterator</a> adaptor is similar to the <a
+href="./transform_iterator.htm">transform iterator adaptor</a> in that
+its <tt>operator*()</tt> applies some function to the result of
+dereferencing the base iterator and then returns the result. The
+difference is that the function must return a reference to some
+existing object (for example, a data member within the
+<tt>value_type</tt> of the base iterator). 
+
+    <p>
+The <a
+    href="projection_iterator.htm#projection_iterator_pair_generator">projection_iterator_pair_generator</a> template
+    is a special two-<a href="../../more/generic_programming.html#type_generator">type generator</a> for mutable and constant versions of a
+    projection iterator. It is defined as follows:
+<blockquote>
+<pre>
+template &lt;class AdaptableUnaryFunction, class Iterator, class ConstIterator&gt;
+struct projection_iterator_pair_generator {
+    typedef typename AdaptableUnaryFunction::result_type value_type;
+    typedef projection_iterator_policies&lt;AdaptableUnaryFunction&gt; policies;
+public:
+    typedef iterator_adaptor&lt;Iterator,policies,value_type&gt; iterator;
+    typedef iterator_adaptor&lt;ConstIterator,policies,value_type,
+        const value_type&amp;,const value_type*&gt; const_iterator;
+};
+</pre>
+</blockquote>
+
+<p>It is assumed that the <tt>Iterator</tt> and <tt>ConstIterator</tt> arguments are corresponding mutable
+and constant iterators. <ul>
+<li>
+Clearly, then, the
+<tt>projection_iterator_pair_generator</tt>'s <tt>iterator</tt> and
+<tt>const_iterator</tt> are <a href="#interoperable">interoperable</a>, since
+they share the same <tt>Policies</tt> and since <tt>Category</tt> and
+<tt>Distance</tt> as supplied by <tt>std::iterator_traits</tt> through the
+<a href="#template_parameters">default template parameters</a> to
+<tt>iterator_adaptor</tt> should be the same.
+
+<li>Since <tt>Iterator</tt> can presumably be converted to
+<tt>ConstIterator</tt>, the projection <tt>iterator</tt> will be convertible to
+the projection <tt>const_iterator</tt>.
+
+<li> Since <tt>projection_iterator_policies</tt> implements only the
+<tt>dereference</tt> operation, and inherits all other behaviors from <tt><a
+href="#default_iterator_policies">default_iterator_policies</a></tt>, which has
+fully-templatized <tt>equal</tt>, <tt>less</tt>, and <tt>distance</tt>
+operations, the <tt>iterator</tt> and <tt>const_iterator</tt> can be freely
+mixed in comparison and subtraction expressions.
+
+</ul>
+
+    <h3><a name="challenge">Challenge</a></h3>
+
+    <p>There is an unlimited number of ways the <tt>iterator_adaptors</tt>
+    class can be used to create iterators. One interesting exercise would be to
+    re-implement the iterators of <tt>std::list</tt> and <tt>std::slist</tt>
+    using <tt>iterator_adaptors</tt>, where the adapted <tt>Iterator</tt> types
+    would be node pointers.
+
+    <h3><a name="concept_model">Concept Model</a></h3>
+    Depending on the <tt>Base</tt> and <tt>Policies</tt> template parameters,
+    an <tt>iterator_adaptor</tt> can be a <a href=
+    "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>, <a
+    href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
+    Iterator</a>, <a href=
+    "http://www.sgi.com/tech/stl/BidirectionalIterator.html">Bidirectional
+    Iterator</a>, or <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a>. 
+
+    <h3><a name="declaration_synopsis">Declaration Synopsis</a></h3>
+<pre>
+template &lt;class Base, class Policies, 
+    class Value = typename std::iterator_traits&lt;Base&gt;::value_type,
+    class Reference = <i>...(see below)</i>,
+    class Pointer = <i>...(see below)</i>,
+    class Category = typename std::iterator_traits&lt;Base&gt;::iterator_category,
+    class Distance = typename std::iterator_traits&lt;Base&gt;::difference_type
+         &gt;
+struct iterator_adaptor
+{
+    typedef Distance difference_type;
+    typedef typename boost::remove_const&lt;Value&gt;::type value_type;
+    typedef Pointer pointer;
+    typedef Reference reference;
+    typedef Category iterator_category;
+    typedef Base base_type;
+    typedef Policies policies_type;
+
+    iterator_adaptor();
+    explicit iterator_adaptor(const Base&amp;, const Policies&amp; = Policies());
+
+    base_type base() const;
+
+    template &lt;class B, class V, class R, class P&gt;
+    iterator_adaptor(
+        const iterator_adaptor&lt;B,Policies,V,R,P,Category,Distance&gt;&amp;);
+
+    reference operator*() const; <a href="#6">[6]</a>
+    <i>operator_arrow_result_type</i> operator-&gt;() const; <a href=
+"#3">[3]</a>
+    <i>value_type</i> operator[](difference_type n) const; <a href="#3">[4]</a>, <a href="#6">[6]</a>
+
+    iterator_adaptor&amp; operator++();
+    iterator_adaptor&amp; operator++(int);
+    iterator_adaptor&amp; operator--();
+    iterator_adaptor&amp; operator--(int);
+
+    iterator_adaptor&amp; operator+=(difference_type n);
+    iterator_adaptor&amp; operator-=(difference_type n);
+
+    iterator_adaptor&amp; operator-(Distance x) const;
+};
+
+template &lt;class B, class P, class V, class R, class Ptr, 
+    class C, class D1, class D2&gt;
+iterator_adaptor&lt;B,P,V,R,Ptr,C,D1&gt;
+operator+(iterator_adaptor&lt;B,P,V,R,Ptr,C,D1&gt;, D2);
+
+template &lt;class B, class P, class V, class R, class Ptr,
+    class C, class D1, class D2&gt;
+iterator_adaptor&lt;B,P,V,R,P,C,D1&gt;
+operator+(D2, iterator_adaptor&lt;B,P,V,R,Ptr,C,D1&gt; p);
+
+template &lt;class B1, class B2, class P, class V1, class V2,
+    class R1, class R2, class P1, class P2, class C, class D&gt;
+Distance operator-(const iterator_adaptor&lt;B1,P,V1,R1,P1,C,D&gt;&amp;, 
+                   const iterator_adaptor&lt;B2,P,V2,R2,P2,C,D&gt;&amp;);
+
+template &lt;class B1, class B2, class P, class V1, class V2,
+    class R1, class R2, class P1, class P2, class C, class D&gt;
+bool operator==(const iterator_adaptor&lt;B1,P,V1,R1,P1,C,D&gt;&amp;, 
+                const iterator_adaptor&lt;B2,P,V2,R2,P2,C,D&gt;&amp;);
+
+// and similarly for operators !=, &lt;, &lt;=, &gt;=, &gt;
+</pre>
+
+    <h3><a name="notes">Notes</a></h3>
+
+    <p><a name="1">[1]</a> The standard specifies that the <tt>value_type</tt>
+    of <tt>const</tt> iterators to <tt>T</tt> (e.g. <tt>const T*</tt>) is
+    <tt><i>non-</i>const T</tt>, while the <tt>pointer</tt> and
+    <tt>reference</tt> types for all <a href=
+    "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterators</a> are
+    <tt>const T*</tt> and <tt>const T&amp;</tt>, respectively. Stripping the
+    <tt>const</tt>-ness of <tt>Value</tt> allows you to easily make a constant
+    iterator by supplying a <tt>const</tt> type for <tt>Value</tt>, and allowing
+    the defaults for the <tt>Pointer</tt> and <tt>Reference</tt> parameters to
+    take effect. Although compilers that don't support partial specialization
+    won't strip <tt>const</tt> for you, having a <tt>const value_type</tt> is
+    often harmless in practice.
+
+    <p><a name="2">[2]</a> If your compiler does not support partial
+    specialization and the base iterator is a builtin pointer type, you
+    will not be able to use the default for <tt>Value</tt> and will have to
+    specify this type explicitly.
+
+    <p><a name="3">[3]</a> The result type for the <tt>operator-&gt;()</tt>
+    depends on the category and value type of the iterator and is somewhat
+    complicated to describe. But be assured, it works in a stardard conforming
+    fashion, providing access to members of the objects pointed to by the
+    iterator.
+
+    <p><a name="4">[4]</a> The result type of <tt>operator[]()</tt> is
+    <tt>value_type</tt> instead of <tt>reference</tt> as might be expected.
+    There are two reasons for this choice. First, the C++ standard only
+    requires that the return type of an arbitrary <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a>'s <tt>operator[]</tt>be ``convertible to T'' (Table 76), so
+    when adapting an arbitrary base iterator we may not have a reference to
+    return. Second, and more importantly, for certain kinds of iterators,
+    returning a reference could cause serious memory problems due to the
+    reference being bound to a temporary object whose lifetime ends inside of
+    the <tt>operator[]</tt>.
+
+    <p><a name="5">[5]</a>
+    The <tt>value_type</tt> of an iterator may not be
+    an abstract base class, however many common uses of iterators
+    never need the <tt>value_type</tt>, only the <tt>reference</tt> type.
+    If you wish to create such an iterator adaptor, use a dummy
+    type such as <tt>char</tt> for the <tt>Value</tt> parameter,
+    and use a reference to your abstract base class for
+    the <tt>Reference</tt> parameter. Note that such an iterator
+    does not fulfill the C++ standards requirements for a
+    <a href= "http://www.sgi.com/tech/stl/ForwardIterator.html">
+    Forward Iterator</a>, so you will need to use a less restrictive
+    iterator category such as <tt>std::input_iterator_tag</tt>.
+
+    <p><a name="6">[6]</a>
+    There is a common misconception that an iterator should have two
+    versions of <tt>operator*</tt> and of <tt>operator[]</tt>, one
+    version that is a <tt>const</tt> member function and one version
+    that is non-<tt>const</tt>. Perhaps the source of this
+    misconception is that containers typically have const and
+    non-const versions of many of their member functions.  Iterators,
+    however, are different. A particular iterator type can be either
+    <i>mutable</i> or <i>constant</i> (but not both).  One can assign
+    to and change the object pointed to by a mutable iterator whereas a
+    constant iterator returns constant objects when dereferenced. Whether
+    the iterator object itself is <tt>const</tt> has nothing to do with
+    whether the iterator is mutable or constant.  This is analogous to
+    the way built-in pointer types behave.  For example, one can
+    modify objects pointed to by a <tt>const</tt> pointer
+<pre>
+    int* const x = new int;
+    int i = 3;
+    *x = i;
+</pre>
+    but one cannot modify objects pointed to by a pointer
+    to <tt>const</tt>
+<pre>
+    int const* x = new int;
+    int i = 3;
+    *x = i;
+</pre>
+
+    <p><a name="7">[7]</a>
+    If you are using a compiler that does not have a version of
+    <tt>std::iterator_traits</tt> that works for pointers (i.e., if your
+    compiler does not support partial specialization) then if the
+    <tt>Base</tt> type is a const pointer, then the correct defaults
+    for the <tt>reference</tt> and <tt>pointer</tt> types can not be
+    deduced. You must specify these types explicitly.
+
+    <hr>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->18 Sep 2001<!--webbot bot="Timestamp" endspan i-checksum="14941" -->
+
+
+    <p>&copy; Copyright Dave Abrahams and 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>
+
+    <!--  LocalWords:  HTML html charset alt gif abrahams htm const iterator
+        incrementable david abrahams
+         -->
+     
+    <!--  LocalWords:  jeremy siek mishandled interoperable typename struct Iter iter src
+         -->
+     
+    <!--  LocalWords:  int bool ForwardIterator BidirectionalIterator BaseIterator
+         -->
+     
+    <!--  LocalWords:  RandomAccessIterator DifferenceType AdaptableUnaryFunction
+         -->
+     
+    <!--  LocalWords:  iostream hpp sizeof InputIterator constness ConstIterator
+         David Abrahams
+         -->
+<!--  LocalWords:  Iterators dereferenced
+ -->
+</html>
+

iterator_traits_test.cpp

@@ -0,0 +1,220 @@
+//  (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
+//  12 Oct 2001 Put static asserts in functions for MWERSK (Dave Abrahams)
+//  04 Mar 2001 Patches for Intel C++ (Dave Abrahams)
+//  19 Feb 2001 Take advantage of improved iterator_traits to do more tests
+//              on MSVC. Reordered some #ifdefs for coherency.
+//              (David Abrahams)
+//  13 Feb 2001 Test new VC6 workarounds (David Abrahams)
+//  11 Feb 2001 Final fixes for Borland (David Abrahams)
+//  11 Feb 2001 Some fixes for Borland get it closer on that compiler
+//              (David Abrahams)
+//  07 Feb 2001 More comprehensive testing; factored out static tests for
+//              better reuse (David Abrahams)
+//  21 Jan 2001 Quick fix to my_iterator, which wasn't returning a
+//              reference type from operator* (David Abrahams)
+//  19 Jan 2001 Initial version with iterator operators (David Abrahams)
+
+#include <boost/detail/iterator.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/operators.hpp>
+#include <boost/static_assert.hpp>
+#include <iterator>
+#include <vector>
+#include <list>
+#include <cassert>
+#include <iostream>
+
+// An iterator for which we can get traits.
+struct my_iterator1
+    : boost::forward_iterator_helper<my_iterator1, char, long, const char*, const char&>
+{
+    my_iterator1(const char* p) : m_p(p) {}
+    
+    bool operator==(const my_iterator1& rhs) const
+        { return this->m_p == rhs.m_p; }
+
+    my_iterator1& operator++() { ++this->m_p; return *this; }
+    const char& operator*() { return *m_p; }
+ private:
+    const char* m_p;
+};
+
+// Used to prove that we don't require std::iterator<> in the hierarchy under
+// MSVC6, and that we can compute all the traits for a standard-conforming UDT
+// iterator.
+struct my_iterator2
+    : boost::equality_comparable<my_iterator2
+    , boost::incrementable<my_iterator2
+    , boost::dereferenceable<my_iterator2,const char*> > >
+{
+    typedef char value_type;
+    typedef long difference_type;
+    typedef const char* pointer;
+    typedef const char& reference;
+    typedef std::forward_iterator_tag iterator_category;
+    
+    my_iterator2(const char* p) : m_p(p) {}
+    
+    bool operator==(const my_iterator2& rhs) const
+        { return this->m_p == rhs.m_p; }
+
+    my_iterator2& operator++() { ++this->m_p; return *this; }
+    const char& operator*() { return *m_p; }
+ private:
+    const char* m_p;
+};
+
+// Used to prove that we're not overly confused by the existence of
+// std::iterator<> in the hierarchy under MSVC6 - we should find that
+// boost::detail::iterator_traits<my_iterator3>::difference_type is int.
+struct my_iterator3 : my_iterator1
+{
+    typedef int difference_type;
+    my_iterator3(const char* p) : my_iterator1(p) {}
+};
+
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct non_portable_tests
+{
+    non_portable_tests()
+    {
+        // Unfortunately, the VC6 standard library doesn't supply these :(
+        BOOST_STATIC_ASSERT((
+            boost::is_same<
+            typename boost::detail::iterator_traits<Iterator>::pointer,
+            pointer
+            >::value));
+
+        BOOST_STATIC_ASSERT((
+            boost::is_same<
+            typename boost::detail::iterator_traits<Iterator>::reference,
+            reference
+            >::value));
+    }
+};
+
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct portable_tests
+{
+    portable_tests()
+    {
+        BOOST_STATIC_ASSERT((
+            boost::is_same<
+            typename boost::detail::iterator_traits<Iterator>::difference_type,
+            difference_type
+            >::value));
+
+        BOOST_STATIC_ASSERT((
+            boost::is_same<
+            typename boost::detail::iterator_traits<Iterator>::iterator_category,
+            category
+            >::value));
+    }
+};
+
+// Test iterator_traits
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct input_iterator_test
+    : portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
+{
+    input_iterator_test()
+    {
+        BOOST_STATIC_ASSERT((
+            boost::is_same<
+            typename boost::detail::iterator_traits<Iterator>::value_type,
+            value_type
+            >::value));
+    }
+};
+
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct non_pointer_test
+    : input_iterator_test<Iterator,value_type,difference_type,pointer,reference,category>
+      , non_portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
+{
+};
+
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct maybe_pointer_test
+    : portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+      , non_portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
+#endif
+{
+};
+
+input_iterator_test<std::istream_iterator<int>, int, std::ptrdiff_t, int*, int&, std::input_iterator_tag>
+        istream_iterator_test;
+
+// 
+#if defined(__BORLANDC__) && !defined(__SGI_STL_PORT)
+typedef ::std::char_traits<char>::off_type distance;
+non_pointer_test<std::ostream_iterator<int>,int,
+    distance,int*,int&,std::output_iterator_tag> ostream_iterator_test;
+#elif defined(BOOST_MSVC_STD_ITERATOR)
+non_pointer_test<std::ostream_iterator<int>,
+    int, void, void, void, std::output_iterator_tag>
+        ostream_iterator_test;
+#else
+non_pointer_test<std::ostream_iterator<int>,
+    void, void, void, void, std::output_iterator_tag>
+        ostream_iterator_test;
+#endif
+
+
+#ifdef __KCC
+  typedef long std_list_diff_type;
+#else
+  typedef std::ptrdiff_t std_list_diff_type;
+#endif
+non_pointer_test<std::list<int>::iterator, int, std_list_diff_type, int*, int&, std::bidirectional_iterator_tag>
+        list_iterator_test;
+
+maybe_pointer_test<std::vector<int>::iterator, int, std::ptrdiff_t, int*, int&, std::random_access_iterator_tag>
+        vector_iterator_test;
+
+maybe_pointer_test<int*, int, std::ptrdiff_t, int*, int&, std::random_access_iterator_tag>
+        int_pointer_test;
+
+non_pointer_test<my_iterator1, char, long, const char*, const char&, std::forward_iterator_tag>
+       my_iterator1_test;
+                    
+non_pointer_test<my_iterator2, char, long, const char*, const char&, std::forward_iterator_tag>
+       my_iterator2_test;
+                    
+non_pointer_test<my_iterator3, char, int, const char*, const char&, std::forward_iterator_tag>
+       my_iterator3_test;
+                    
+int main()
+{
+    char chars[100];
+    int ints[100];
+    
+    for (std::ptrdiff_t length = 3; length < 100; length += length / 3)
+    {
+        std::list<int> l(length);
+        assert(boost::detail::distance(l.begin(), l.end()) == length);
+        
+        std::vector<int> v(length);
+        assert(boost::detail::distance(v.begin(), v.end()) == length);
+
+        assert(boost::detail::distance(&ints[0], ints + length) == length);
+        assert(boost::detail::distance(my_iterator1(chars), my_iterator1(chars + length)) == length);
+        assert(boost::detail::distance(my_iterator2(chars), my_iterator2(chars + length)) == length);
+        assert(boost::detail::distance(my_iterator3(chars), my_iterator3(chars + length)) == length);
+    }
+    return 0;
+}

iterators_test.cpp

@@ -1,169 +0,0 @@
-//  Demonstrate and test boost/operators.hpp on std::iterators  --------------//
-
-//  (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
-//  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
-
-#include <string>
-#include <iostream>
-using namespace std;
-
-#include <boost/operators.hpp>
-using namespace boost;
-
-
-template <class T, class R, class P>
-struct test_iter
-  : public boost::random_access_iterator_helper<
-     test_iter<T,R,P>, T, std::ptrdiff_t, P, R>
-{
-  typedef test_iter self;
-  typedef R Reference;
-  typedef std::ptrdiff_t Distance;
-
-public:
-  test_iter(T* i) : _i(i) { }
-  test_iter(const self& x) : _i(x._i) { }
-  self& operator=(const self& x) { _i = x._i; return *this; }
-  Reference operator*() const { return *_i; }
-  self& operator++() { ++_i; return *this; }
-  self& operator--() { --_i; return *this; }
-  self& operator+=(Distance n) { _i += n; return *this; }
-  self& operator-=(Distance n) { _i -= n; return *this; }
-  bool operator==(const self& x) const { return _i == x._i; }
-  bool operator<(const self& x) const { return _i < x._i; }
-  friend Distance operator-(const self& x, const self& y) {
-    return x._i - y._i; 
-  }
-protected:
-  T* _i;
-};
-
-
-int
-main()
-{
-  string array[] = { "apple", "orange", "pear", "peach", "grape", "plum"  };
-  {
-    test_iter<string,string&,string*> i = array, 
-      ie = array + sizeof(array)/sizeof(string);
-
-    // Tests for all of the operators added by random_access_iterator_helper
-
-    // test i++
-    while (i != ie)
-      cout << *i++ << " ";
-    cout << endl;
-    i = array;
-
-    // test i--
-    while (ie != i) {
-      ie--;
-      cout << *ie << " ";
-    }
-    cout << endl;
-    ie = array + sizeof(array)/sizeof(string);
-
-    // test i->m
-    while (i != ie) {
-      cout << i->size() << " ";
-      ++i;
-    }
-    cout << endl;
-    i = array;
-
-    // test i + n
-    while (i < ie) {
-      cout << *i << " ";
-      i = i + 2;
-    }
-    cout << endl;
-    i = array;
-
-    // test n + i
-    while (i < ie) {
-      cout << *i << " ";
-      i = ptrdiff_t(2) + i;
-    }
-    cout << endl;
-    i = array;
-
-    // test i - n
-    while (ie > i) {
-      ie = ie - 2;
-      cout << *ie << " ";
-    }
-    cout << endl;
-    ie = array + sizeof(array)/sizeof(string);
-
-    // test i[n]
-    for (std::size_t j = 0; j < sizeof(array)/sizeof(string); ++j)
-      cout << i[j] << " ";
-    cout << endl;
-  }
-  {
-    test_iter<string, const string&, const string*> i = array, 
-      ie = array + sizeof(array)/sizeof(string);
-
-    // Tests for all of the operators added by random_access_iterator_helper
-
-    // test i++
-    while (i != ie)
-      cout << *i++ << " ";
-    cout << endl;
-    i = array;
-
-    // test i--
-    while (ie != i) {
-      ie--;
-      cout << *ie << " ";
-    }
-    cout << endl;
-    ie = array + sizeof(array)/sizeof(string);
-
-    // test i->m
-    while (i != ie) {
-      cout << i->size() << " ";
-      ++i;
-    }
-    cout << endl;
-    i = array;
-
-    // test i + n
-    while (i < ie) {
-      cout << *i << " ";
-      i = i + 2;
-    }
-    cout << endl;
-    i = array;
-
-    // test n + i
-    while (i < ie) {
-      cout << *i << " ";
-      i = ptrdiff_t(2) + i;
-    }
-    cout << endl;
-    i = array;
-
-    // test i - n
-    while (ie > i) {
-      ie = ie - 2;
-      cout << *ie << " ";
-    }
-    cout << endl;
-    ie = array + sizeof(array)/sizeof(string);
-
-    // test i[n]
-    for (std::size_t j = 0; j < sizeof(array)/sizeof(string); ++j)
-      cout << i[j] << " ";
-    cout << endl;
-  }
-  return 0;
-}

noncopyable_test.cpp

@@ -1,38 +0,0 @@
-//  boost class noncopyable test program  ------------------------------------//
-
-//  (C) Copyright boost.org 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
-//   9 Jun 99  Add unnamed namespace
-//   2 Jun 99  Initial Version
-
-#include <boost/utility.hpp>
-#include <iostream>
-
-//  This program demonstrates compiler errors resulting from trying to copy
-//  construct or copy assign a class object derived from class noncopyable.
-
-namespace
-{
-    class DontTreadOnMe : boost::noncopyable
-    {
-    public:
-         DontTreadOnMe() { std::cout << "defanged!" << std::endl; }
-    };   // DontTreadOnMe
-
-}   // unnamed namespace
-
-int main()
-{
-    DontTreadOnMe object1;
-    DontTreadOnMe object2(object1);
-    object1 = object2;
-    return 0;
-}   // main
-  

operators_test.cpp

@@ -1,481 +0,0 @@
-//  Demonstrate and test boost/operators.hpp  -------------------------------//
-
-//  (C) Copyright Beman Dawes 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
-//  04 Jun 00 Added regression test for a bug I found (David Abrahams)
-//  17 Jun 00 Fix for broken compilers (Aleksey Gurtovoy)
-//  ?? ??? 00 Major update to randomly test all one- and two- argument forms by
-//            wrapping integral types and comparing the results of operations to
-//            the results for the raw types (David Abrahams)
-//  12 Dec 99 Minor update, output confirmation message.
-//  15 Nov 99 Initial version
-
-#include <boost/operators.hpp>
-#include <cassert>
-#include <iostream>
-#include <boost/min_rand.hpp>
-
-
-namespace
-{
-    // avoiding a template version of true_value so as to not confuse VC++
-    int true_value(int x) { return x; }
-    long true_value(long x) { return x; }
-    signed char true_value(signed char x) { return x; }
-    unsigned int true_value(unsigned int x) { return x; }
-    unsigned long true_value(unsigned long x) { return x; }
-    unsigned char true_value(unsigned char x) { return x; }
-
-    // The use of operators<> here tended to obscure interactions with certain
-    // compiler bugs
-    template <class T>
-    class Wrapped1 : boost::operators<Wrapped1<T> >
-    {
-    public:
-        explicit Wrapped1( T v = T() ) : _value(v) {}
-        T value() const { return _value; }
-
-        bool operator<(const Wrapped1& x) const { return _value < x._value; }
-        bool operator==(const Wrapped1& x) const { return _value == x._value; }
-        
-        Wrapped1& operator+=(const Wrapped1& x)
-          { _value += x._value; return *this; }
-        Wrapped1& operator-=(const Wrapped1& x)
-          { _value -= x._value; return *this; }
-        Wrapped1& operator*=(const Wrapped1& x)
-          { _value *= x._value; return *this; }
-        Wrapped1& operator/=(const Wrapped1& x)
-          { _value /= x._value; return *this; }
-        Wrapped1& operator%=(const Wrapped1& x)
-          { _value %= x._value; return *this; }
-        Wrapped1& operator|=(const Wrapped1& x)
-          { _value |= x._value; return *this; }
-        Wrapped1& operator&=(const Wrapped1& x)
-          { _value &= x._value; return *this; }
-        Wrapped1& operator^=(const Wrapped1& x)
-          { _value ^= x._value; return *this; }
-        Wrapped1& operator++()               { ++_value; return *this; }
-        Wrapped1& operator--()               { --_value; return *this; }
-        
-    private:
-        T _value;
-    };
-    template <class T>
-    T true_value(Wrapped1<T> x) { return x.value(); }    
-
-    template <class T, class U>
-    class Wrapped2 :
-        boost::operators<Wrapped2<T, U> >,
-        boost::operators2<Wrapped2<T, U>, U>
-    {
-    public:
-        explicit Wrapped2( T v = T() ) : _value(v) {}
-        T value() const { return _value; }
-
-        bool operator<(const Wrapped2& x) const { return _value < x._value; }
-        bool operator==(const Wrapped2& x) const { return _value == x._value; }
-        
-        Wrapped2& operator+=(const Wrapped2& x)
-          { _value += x._value; return *this; }
-        Wrapped2& operator-=(const Wrapped2& x)
-          { _value -= x._value; return *this; }
-        Wrapped2& operator*=(const Wrapped2& x)
-          { _value *= x._value; return *this; }
-        Wrapped2& operator/=(const Wrapped2& x)
-          { _value /= x._value; return *this; }
-        Wrapped2& operator%=(const Wrapped2& x)
-          { _value %= x._value; return *this; }
-        Wrapped2& operator|=(const Wrapped2& x)
-          { _value |= x._value; return *this; }
-        Wrapped2& operator&=(const Wrapped2& x)
-          { _value &= x._value; return *this; }
-        Wrapped2& operator^=(const Wrapped2& x)
-          { _value ^= x._value; return *this; }
-        Wrapped2& operator++()                { ++_value; return *this; }
-        Wrapped2& operator--()                { --_value; return *this; }
-         
-        bool operator<(U u) const { return _value < u; }
-        bool operator>(U u) const { return _value > u; }
-        bool operator==(U u) const { return _value == u; }
-        Wrapped2& operator+=(U u) { _value += u; return *this; }
-        Wrapped2& operator-=(U u) { _value -= u; return *this; }
-        Wrapped2& operator*=(U u) { _value *= u; return *this; }
-        Wrapped2& operator/=(U u) { _value /= u; return *this; }
-        Wrapped2& operator%=(U u) { _value %= u; return *this; }
-        Wrapped2& operator|=(U u) { _value |= u; return *this; }
-        Wrapped2& operator&=(U u) { _value &= u; return *this; }
-        Wrapped2& operator^=(U u) { _value ^= u; return *this; }
-
-    private:
-        T _value;
-    };
-    template <class T, class U>
-    T true_value(Wrapped2<T,U> x) { return x.value(); }
-    
-    //  MyInt uses only the single template-argument form of all_operators<>
-    typedef Wrapped1<int> MyInt;
-
-    typedef Wrapped2<long, long> MyLong;
-
-    template <class X1, class Y1, class X2, class Y2>
-    void sanity_check(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        assert(true_value(y1) == true_value(y2));
-        assert(true_value(x1) == true_value(x2));
-    }
-
-    template <class X1, class Y1, class X2, class Y2>
-    void test_less_than_comparable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        assert((x1 < y1) == (x2 < y2));
-        assert((x1 <= y1) == (x2 <= y2));
-        assert((x1 >= y1) == (x2 >= y2));
-        assert((x1 > y1) == (x2 > y2));
-    }
-    
-    template <class X1, class Y1, class X2, class Y2>
-    void test_less_than_comparable(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        sanity_check(x1, y1, x2, y2);
-        test_less_than_comparable_aux(x1, y1, x2, y2);
-        test_less_than_comparable_aux(y1, x1, y2, x2);
-    }
-
-    template <class X1, class Y1, class X2, class Y2>
-    void test_equality_comparable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        assert((x1 == y1) == (x2 == y2));
-        assert((x1 != y1) == (x2 != y2));
-    }
-    
-    template <class X1, class Y1, class X2, class Y2>
-    void test_equality_comparable(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        sanity_check(x1, y1, x2, y2);
-        test_equality_comparable_aux(x1, y1, x2, y2);
-        test_equality_comparable_aux(y1, x1, y2, x2);
-    }
-
-    template <class X1, class Y1, class X2, class Y2>
-    void test_multipliable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        assert((x1 * y1).value() == (x2 * y2));
-    }
-    
-    template <class X1, class Y1, class X2, class Y2>
-    void test_multipliable(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        sanity_check(x1, y1, x2, y2);
-        test_multipliable_aux(x1, y1, x2, y2);
-        test_multipliable_aux(y1, x1, y2, x2);
-    }
-    
-    template <class X1, class Y1, class X2, class Y2>
-    void test_addable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        assert((x1 + y1).value() == (x2 + y2));
-    }
-    
-    template <class X1, class Y1, class X2, class Y2>
-    void test_addable(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        sanity_check(x1, y1, x2, y2);
-        test_addable_aux(x1, y1, x2, y2);
-        test_addable_aux(y1, x1, y2, x2);
-    }
-    
-    template <class X1, class Y1, class X2, class Y2>
-    void test_subtractable(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        sanity_check(x1, y1, x2, y2);
-        assert((x1 - y1).value() == x2 - y2);
-    }
-
-    template <class X1, class Y1, class X2, class Y2>
-    void test_dividable(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        sanity_check(x1, y1, x2, y2);
-        if (y2 != 0)
-            assert((x1 / y1).value() == x2 / y2);
-    }
-    
-    template <class X1, class Y1, class X2, class Y2>
-    void test_modable(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        sanity_check(x1, y1, x2, y2);
-        if (y2 != 0)
-            assert((x1 / y1).value() == x2 / y2);
-    }
-    
-    template <class X1, class Y1, class X2, class Y2>
-    void test_xorable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        assert((x1 ^ y1).value() == (x2 ^ y2));
-    }
-    
-    template <class X1, class Y1, class X2, class Y2>
-    void test_xorable(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        sanity_check(x1, y1, x2, y2);
-        test_xorable_aux(x1, y1, x2, y2);
-        test_xorable_aux(y1, x1, y2, x2);
-    }
-    
-    template <class X1, class Y1, class X2, class Y2>
-    void test_andable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        assert((x1 & y1).value() == (x2 & y2));
-    }
-    
-    template <class X1, class Y1, class X2, class Y2>
-    void test_andable(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        sanity_check(x1, y1, x2, y2);
-        test_andable_aux(x1, y1, x2, y2);
-        test_andable_aux(y1, x1, y2, x2);
-    }
-    
-    template <class X1, class Y1, class X2, class Y2>
-    void test_orable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        assert((x1 | y1).value() == (x2 | y2));
-    }
-    
-    template <class X1, class Y1, class X2, class Y2>
-    void test_orable(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        sanity_check(x1, y1, x2, y2);
-        test_orable_aux(x1, y1, x2, y2);
-        test_orable_aux(y1, x1, y2, x2);
-    }
-    
-    template <class X1, class X2>
-    void test_incrementable(X1 x1, X2 x2)
-    {
-        sanity_check(x1, x1, x2, x2);
-        assert(x1++.value() == x2++);
-        assert(x1.value() == x2);
-    }
-    
-    template <class X1, class X2>
-    void test_decrementable(X1 x1, X2 x2)
-    {
-        sanity_check(x1, x1, x2, x2);
-        assert(x1--.value() == x2--);
-        assert(x1.value() == x2);
-    }
-    
-    template <class X1, class Y1, class X2, class Y2>
-    void test_all(X1 x1, Y1 y1, X2 x2, Y2 y2)
-    {
-        test_less_than_comparable(x1, y1, x2, y2);
-        test_equality_comparable(x1, y1, x2, y2);
-        test_multipliable(x1, y1, x2, y2);
-        test_addable(x1, y1, x2, y2);
-        test_subtractable(x1, y1, x2, y2);
-        test_dividable(x1, y1, x2, y2);
-        test_modable(x1, y1, x2, y2);
-        test_xorable(x1, y1, x2, y2);
-        test_andable(x1, y1, x2, y2);
-        test_orable(x1, y1, x2, y2);
-        test_incrementable(x1, x2);
-        test_decrementable(x1, x2);
-    }
-    
-    template <class Big, class Small>
-    struct tester
-    {
-        void operator()(boost::min_rand& randomizer) const
-        {
-            Big b1 = Big(randomizer());
-            Big b2 = Big(randomizer());
-            Small s = Small(randomizer());
-            
-            test_all(Wrapped1<Big>(b1), Wrapped1<Big>(b2), b1, b2);
-            test_all(Wrapped2<Big, Small>(b1), s, b1, s);
-        }
-    };
-
-    // added as a regression test. We had a bug which this uncovered.
-    struct Point
-        : boost::addable<Point,
-        boost::subtractable<Point> >
-    {
-        Point( int h, int v ) : h(h), v(v) {}
-        Point() :h(0), v(0) {}
-        const Point& operator+=( const Point& rhs ) { h += rhs.h; v += rhs.v; return *this; }
-        const Point& operator-=( const Point& rhs ) { h -= rhs.h; v -= rhs.v; return *this; }
-
-        int h;
-        int v;
-    };
-} // unnamed namespace
-
-
-// workaround for MSVC bug; for some reasons the compiler doesn't instantiate
-// inherited operator templates at the moment it must, so the following
-// explicit instantiations force it to do that.
-
-#if defined(BOOST_MSVC) && (_MSC_VER <= 1200)
-template Wrapped1<int>;
-template Wrapped1<long>;
-template Wrapped1<unsigned int>;
-template Wrapped1<unsigned long>;
-
-template Wrapped2<int, int>;
-template Wrapped2<int, signed char>;
-template Wrapped2<long, signed char>;
-template Wrapped2<long, int>;
-template Wrapped2<long, long>;
-template Wrapped2<unsigned int, unsigned int>;
-template Wrapped2<unsigned int, unsigned char>;
-template Wrapped2<unsigned long, unsigned int>;
-template Wrapped2<unsigned long, unsigned char>;
-template Wrapped2<unsigned long, unsigned long>;
-#endif
-
-#ifdef NDEBUG
-#error This program is pointless when NDEBUG disables assert()!
-#endif
-
-int main()
-{
-    // Regression test.
-    Point x;
-    x = x + Point(3, 4);
-    x = x - Point(3, 4);
-    
-    for (int n = 0; n < 10000; ++n)
-    {
-        boost::min_rand r;
-        tester<long, int>()(r);
-        tester<long, signed char>()(r);
-        tester<long, long>()(r);
-        tester<int, int>()(r);
-        tester<int, signed char>()(r);
-        
-        tester<unsigned long, unsigned int>()(r);
-        tester<unsigned long, unsigned char>()(r);
-        tester<unsigned long, unsigned long>()(r);
-        tester<unsigned int, unsigned int>()(r);
-        tester<unsigned int, unsigned char>()(r);
-    }
-    
-    MyInt i1(1);
-    MyInt i2(2);
-    MyInt i;
-
-    assert( i1.value() == 1 );
-    assert( i2.value() == 2 );
-    assert( i.value() == 0 );
-
-    i = i2;
-    assert( i.value() == 2 );
-    assert( i2 == i );
-    assert( i1 != i2 );
-    assert( i1 <  i2 );
-    assert( i1 <= i2 );
-    assert( i <= i2 );
-    assert( i2 >  i1 );
-    assert( i2 >= i1 );
-    assert( i2 >= i );
-
-    i = i1 + i2; assert( i.value() == 3 );
-    i = i + i2; assert( i.value() == 5 );
-    i = i - i1; assert( i.value() == 4 );
-    i = i * i2; assert( i.value() == 8 );
-    i = i / i2; assert( i.value() == 4 );
-    i = i % (i - i1); assert( i.value() == 1 );
-    i = i2 + i2; assert( i.value() == 4 );
-    i = i1 | i2 | i; assert( i.value() == 7 );
-    i = i & i2; assert( i.value() == 2 );
-    i = i + i1; assert( i.value() == 3 );
-    i = i ^ i1; assert( i.value() == 2 );
-    i = (i+i1)*(i2|i1); assert( i.value() == 9 );
-    
-    MyLong j1(1);
-    MyLong j2(2);
-    MyLong j;
-
-    assert( j1.value() == 1 );
-    assert( j2.value() == 2 );
-    assert( j.value() == 0 );
-
-    j = j2;
-    assert( j.value() == 2 );
-    
-    assert( j2 == j );
-    assert( 2 == j );
-    assert( j2 == 2 );    
-    assert( j == j2 );
-    assert( j1 != j2 );
-    assert( j1 != 2 );
-    assert( 1 != j2 );
-    assert( j1 <  j2 );
-    assert( 1 <  j2 );
-    assert( j1 <  2 );
-    assert( j1 <= j2 );
-    assert( 1 <= j2 );
-    assert( j1 <= j );
-    assert( j <= j2 );
-    assert( 2 <= j2 );
-    assert( j <= 2 );
-    assert( j2 >  j1 );
-    assert( 2 >  j1 );
-    assert( j2 >  1 );
-    assert( j2 >= j1 );
-    assert( 2 >= j1 );
-    assert( j2 >= 1 );
-    assert( j2 >= j );
-    assert( 2 >= j );
-    assert( j2 >= 2 );
-
-    assert( (j1 + 2) == 3 );
-    assert( (1 + j2) == 3 );
-    j = j1 + j2; assert( j.value() == 3 );
-    
-    assert( (j + 2) == 5 );
-    assert( (3 + j2) == 5 );
-    j = j + j2; assert( j.value() == 5 );
-    
-    assert( (j - 1) == 4 );
-    j = j - j1; assert( j.value() == 4 );
-    
-    assert( (j * 2) == 8 );
-    assert( (4 * j2) == 8 );
-    j = j * j2; assert( j.value() == 8 );
-    
-    assert( (j / 2) == 4 );
-    j = j / j2; assert( j.value() == 4 );
-    
-    assert( (j % 3) == 1 );
-    j = j % (j - j1); assert( j.value() == 1 );
-    
-    j = j2 + j2; assert( j.value() == 4 );
-    
-    assert( (1 | j2 | j) == 7 );
-    assert( (j1 | 2 | j) == 7 );
-    assert( (j1 | j2 | 4) == 7 );
-    j = j1 | j2 | j; assert( j.value() == 7 );
-    
-    assert( (7 & j2) == 2 );
-    assert( (j & 2) == 2 );
-    j = j & j2; assert( j.value() == 2 );
-    
-    j = j | j1; assert( j.value() == 3 );
-    
-    assert( (3 ^ j1) == 2 );
-    assert( (j ^ 1) == 2 );
-    j = j ^ j1; assert( j.value() == 2 );
-    
-    j = (j+j1)*(j2|j1); assert( j.value() == 9 );
-    
-    std::cout << "0 errors detected\n";
-    return 0;
-}

type_traits_test.cpp

@@ -1,534 +0,0 @@
-//  (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.
-
-/* Release notes:
-   23rd July 2000:
-      Removed all call_traits tests to call_traits_test.cpp
-      Removed all compressed_pair tests to compressed_pair_tests.cpp
-      Improved tests macros
-      Tidied up specialistions of type_types classes for test cases.
-*/
-
-#include <iostream>
-#include <typeinfo>
-
-#include <boost/type_traits.hpp>
-
-using namespace boost;
-
-#ifdef __BORLANDC__
-#pragma option -w-ccc -w-rch -w-eff -w-aus
-#endif
-
-//
-// define tests here
-unsigned failures = 0;
-unsigned test_count = 0;
-
-#define value_test(v, x) ++test_count;\
-                         if(v != x){++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;}
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#define type_test(v, x)  ++test_count;\
-                         if(is_same<v, x>::value == false){\
-                           ++failures; \
-                           std::cout << "checking type of " << #x << "...failed" << std::endl; \
-                           std::cout << "   expected type was " << #v << std::endl; \
-                           std::cout << "   " << typeid(is_same<v, x>).name() << "::value is false" << std::endl; }
-#else
-#define type_test(v, x)  ++test_count;\
-                         if(typeid(v) != typeid(x)){\
-                           ++failures; \
-                           std::cout << "checking type of " << #x << "...failed" << std::endl; \
-                           std::cout << "   expected type was " << #v << std::endl; \
-                           std::cout << "   " << "typeid(" #v ") != typeid(" #x ")" << std::endl; }
-#endif
-
-// Since there is no compiler support, we should specialize:
-//  is_enum for all enumerations (is_enum implies is_POD)
-//  is_union for all unions
-//  is_empty for all empty composites
-//  is_POD for all PODs (except enums) (is_POD implies has_*)
-//  has_* for any UDT that has that trait and is not POD
-
-enum enum_UDT{ one, two, three };
-struct UDT
-{
-   UDT();
-   ~UDT();
-   UDT(const UDT&);
-   UDT& operator=(const UDT&);
-   int i;
-
-   void f1();
-   int f2();
-   int f3(int);
-   int f4(int, float);
-};
-
-struct POD_UDT { int x; };
-struct empty_UDT{ ~empty_UDT(){}; };
-struct empty_POD_UDT{};
-union union_UDT
-{
-  int x;
-  double y;
-  ~union_UDT();
-};
-union POD_union_UDT
-{
-  int x;
-  double y;
-};
-union empty_union_UDT
-{
-  ~empty_union_UDT();
-};
-union empty_POD_union_UDT{};
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-namespace boost {
-template <> struct is_enum<enum_UDT>
-{ static const bool value = true; };
-template <> struct is_POD<POD_UDT>
-{ static const bool value = true; };
-// this type is not POD, so we have to specialize the has_* individually
-template <> struct has_trivial_constructor<empty_UDT>
-{ static const bool value = true; };
-template <> struct has_trivial_copy<empty_UDT>
-{ static const bool value = true; };
-template <> struct has_trivial_assign<empty_UDT>
-{ static const bool value = true; };
-template <> struct is_POD<empty_POD_UDT>
-{ static const bool value = true; };
-template <> struct is_union<union_UDT>
-{ static const bool value = true; };
-template <> struct is_union<POD_union_UDT>
-{ static const bool value = true; };
-template <> struct is_POD<POD_union_UDT>
-{ static const bool value = true; };
-template <> struct is_union<empty_union_UDT>
-{ static const bool value = true; };
-// this type is not POD, so we have to specialize the has_* individually
-template <> struct has_trivial_constructor<empty_union_UDT>
-{ static const bool value = true; };
-template <> struct has_trivial_copy<empty_union_UDT>
-{ static const bool value = true; };
-template <> struct has_trivial_assign<empty_union_UDT>
-{ static const bool value = true; };
-template <> struct is_union<empty_POD_union_UDT>
-{ static const bool value = true; };
-template <> struct is_POD<empty_POD_union_UDT>
-{ static const bool value = true; };
-}
-#else
-namespace boost {
-template <> struct is_enum<enum_UDT>
-{ enum{ value = true }; };
-template <> struct is_POD<POD_UDT>
-{ enum{ value = true }; };
-// this type is not POD, so we have to specialize the has_* individually
-template <> struct has_trivial_constructor<empty_UDT>
-{ enum{ value = true }; };
-template <> struct has_trivial_copy<empty_UDT>
-{ enum{ value = true }; };
-template <> struct has_trivial_assign<empty_UDT>
-{ enum{ value = true }; };
-template <> struct is_POD<empty_POD_UDT>
-{ enum{ value = true }; };
-template <> struct is_union<union_UDT>
-{ enum{ value = true }; };
-template <> struct is_union<POD_union_UDT>
-{ enum{ value = true }; };
-template <> struct is_POD<POD_union_UDT>
-{ enum{ value = true }; };
-template <> struct is_union<empty_union_UDT>
-{ enum{ value = true }; };
-// this type is not POD, so we have to specialize the has_* individually
-template <> struct has_trivial_constructor<empty_union_UDT>
-{ enum{ value = true }; };
-template <> struct has_trivial_copy<empty_union_UDT>
-{ enum{ value = true }; };
-template <> struct has_trivial_assign<empty_union_UDT>
-{ enum{ value = true }; };
-template <> struct is_union<empty_POD_union_UDT>
-{ enum{ value = true }; };
-template <> struct is_POD<empty_POD_union_UDT>
-{ enum{ value = true }; };
-}
-#endif
-
-// Steve: All comments that I (Steve Cleary) have added below are prefixed with
-//  "Steve:"  The failures that BCB4 has on the tests are due to Borland's
-//  not considering cv-qual's as a part of the type -- they are considered
-//  compiler hints only.  These failures should be fixed before long.
-
-int main()
-{
-   std::cout << "Checking type operations..." << std::endl << std::endl;
-
-   // cv-qualifiers applied to reference types should have no effect
-   // declare these here for later use with is_reference and remove_reference:
-   typedef int& r_type;
-   typedef const r_type cr_type;
-
-   type_test(int, remove_reference<int>::type)
-   type_test(const int, remove_reference<const int>::type)
-   type_test(int, remove_reference<int&>::type)
-   type_test(const int, remove_reference<const int&>::type)
-   type_test(volatile int, remove_reference<volatile int&>::type)
-   type_test(int, remove_reference<cr_type>::type)
-
-   type_test(int, remove_const<const int>::type)
-   // Steve: fails on BCB4
-   type_test(volatile int, remove_const<volatile int>::type)
-   // Steve: fails on BCB4
-   type_test(volatile int, remove_const<const volatile int>::type)
-   type_test(int, remove_const<int>::type)
-   type_test(int*, remove_const<int* const>::type)
-   type_test(int, remove_volatile<volatile int>::type)
-   // Steve: fails on BCB4
-   type_test(const int, remove_volatile<const int>::type)
-   // Steve: fails on BCB4
-   type_test(const int, remove_volatile<const volatile int>::type)
-   type_test(int, remove_volatile<int>::type)
-   type_test(int*, remove_volatile<int* volatile>::type)
-   type_test(int, remove_cv<volatile int>::type)
-   type_test(int, remove_cv<const int>::type)
-   type_test(int, remove_cv<const volatile int>::type)
-   type_test(int, remove_cv<int>::type)
-   type_test(int*, remove_cv<int* volatile>::type)
-   type_test(int*, remove_cv<int* const>::type)
-   type_test(int*, remove_cv<int* const volatile>::type)
-   type_test(const int *, remove_cv<const int * const>::type)
-   type_test(int, remove_bounds<int>::type)
-   type_test(int*, remove_bounds<int*>::type)
-   type_test(int, remove_bounds<int[3]>::type)
-   type_test(int[3], remove_bounds<int[2][3]>::type)
-
-   std::cout << std::endl << "Checking type properties..." << std::endl << std::endl;
-
-   value_test(true, (is_same<int, int>::value))
-   value_test(false, (is_same<int, const int>::value))
-   value_test(false, (is_same<int, int&>::value))
-   value_test(false, (is_same<int*, const int*>::value))
-   value_test(false, (is_same<int*, int*const>::value))
-   value_test(false, (is_same<int, int[2]>::value))
-
-   value_test(false, is_const<int>::value)
-   value_test(true, is_const<const int>::value)
-   value_test(false, is_const<volatile int>::value)
-   value_test(true, is_const<const volatile int>::value)
-
-   value_test(false, is_volatile<int>::value)
-   value_test(false, is_volatile<const int>::value)
-   value_test(true, is_volatile<volatile int>::value)
-   value_test(true, is_volatile<const volatile int>::value)
-
-   value_test(true, is_void<void>::value)
-   // Steve: fails on BCB4
-   // JM: but looks as though it should according to [3.9.3p1]?
-   //value_test(false, is_void<const void>::value)
-   value_test(false, is_void<int>::value)
-
-   value_test(false, is_standard_unsigned_integral<UDT>::value)
-   value_test(false, is_standard_unsigned_integral<void>::value)
-   value_test(false, is_standard_unsigned_integral<bool>::value)
-   value_test(false, is_standard_unsigned_integral<char>::value)
-   value_test(false, is_standard_unsigned_integral<signed char>::value)
-   value_test(true, is_standard_unsigned_integral<unsigned char>::value)
-   value_test(false, is_standard_unsigned_integral<wchar_t>::value)
-   value_test(false, is_standard_unsigned_integral<short>::value)
-   value_test(true, is_standard_unsigned_integral<unsigned short>::value)
-   value_test(false, is_standard_unsigned_integral<int>::value)
-   value_test(true, is_standard_unsigned_integral<unsigned int>::value)
-   value_test(false, is_standard_unsigned_integral<long>::value)
-   value_test(true, is_standard_unsigned_integral<unsigned long>::value)
-   value_test(false, is_standard_unsigned_integral<float>::value)
-   value_test(false, is_standard_unsigned_integral<double>::value)
-   value_test(false, is_standard_unsigned_integral<long double>::value)
-   #ifdef ULLONG_MAX
-   value_test(false, is_standard_unsigned_integral<long long>::value)
-   value_test(false, is_standard_unsigned_integral<unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(false, is_standard_unsigned_integral<__int64>::value)
-   value_test(false, is_standard_unsigned_integral<unsigned __int64>::value)
-   #endif
-
-   value_test(false, is_standard_signed_integral<UDT>::value)
-   value_test(false, is_standard_signed_integral<void>::value)
-   value_test(false, is_standard_signed_integral<bool>::value)
-   value_test(false, is_standard_signed_integral<char>::value)
-   value_test(true, is_standard_signed_integral<signed char>::value)
-   value_test(false, is_standard_signed_integral<unsigned char>::value)
-   value_test(false, is_standard_signed_integral<wchar_t>::value)
-   value_test(true, is_standard_signed_integral<short>::value)
-   value_test(false, is_standard_signed_integral<unsigned short>::value)
-   value_test(true, is_standard_signed_integral<int>::value)
-   value_test(false, is_standard_signed_integral<unsigned int>::value)
-   value_test(true, is_standard_signed_integral<long>::value)
-   value_test(false, is_standard_signed_integral<unsigned long>::value)
-   value_test(false, is_standard_signed_integral<float>::value)
-   value_test(false, is_standard_signed_integral<double>::value)
-   value_test(false, is_standard_signed_integral<long double>::value)
-   #ifdef ULLONG_MAX
-   value_test(false, is_standard_signed_integral<long long>::value)
-   value_test(false, is_standard_signed_integral<unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(false, is_standard_signed_integral<__int64>::value)
-   value_test(false, is_standard_signed_integral<unsigned __int64>::value)
-   #endif
-
-   value_test(false, is_standard_arithmetic<UDT>::value)
-   value_test(false, is_standard_arithmetic<void>::value)
-   value_test(true, is_standard_arithmetic<bool>::value)
-   value_test(true, is_standard_arithmetic<char>::value)
-   value_test(true, is_standard_arithmetic<signed char>::value)
-   value_test(true, is_standard_arithmetic<unsigned char>::value)
-   value_test(true, is_standard_arithmetic<wchar_t>::value)
-   value_test(true, is_standard_arithmetic<short>::value)
-   value_test(true, is_standard_arithmetic<unsigned short>::value)
-   value_test(true, is_standard_arithmetic<int>::value)
-   value_test(true, is_standard_arithmetic<unsigned int>::value)
-   value_test(true, is_standard_arithmetic<long>::value)
-   value_test(true, is_standard_arithmetic<unsigned long>::value)
-   value_test(true, is_standard_arithmetic<float>::value)
-   value_test(true, is_standard_arithmetic<double>::value)
-   value_test(true, is_standard_arithmetic<long double>::value)
-   #ifdef ULLONG_MAX
-   value_test(false, is_standard_arithmetic<long long>::value)
-   value_test(false, is_standard_arithmetic<unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(false, is_standard_arithmetic<__int64>::value)
-   value_test(false, is_standard_arithmetic<unsigned __int64>::value)
-   #endif
-
-   value_test(false, is_standard_fundamental<UDT>::value)
-   value_test(true, is_standard_fundamental<void>::value)
-   value_test(true, is_standard_fundamental<bool>::value)
-   value_test(true, is_standard_fundamental<char>::value)
-   value_test(true, is_standard_fundamental<signed char>::value)
-   value_test(true, is_standard_fundamental<unsigned char>::value)
-   value_test(true, is_standard_fundamental<wchar_t>::value)
-   value_test(true, is_standard_fundamental<short>::value)
-   value_test(true, is_standard_fundamental<unsigned short>::value)
-   value_test(true, is_standard_fundamental<int>::value)
-   value_test(true, is_standard_fundamental<unsigned int>::value)
-   value_test(true, is_standard_fundamental<long>::value)
-   value_test(true, is_standard_fundamental<unsigned long>::value)
-   value_test(true, is_standard_fundamental<float>::value)
-   value_test(true, is_standard_fundamental<double>::value)
-   value_test(true, is_standard_fundamental<long double>::value)
-   #ifdef ULLONG_MAX
-   value_test(false, is_standard_fundamental<long long>::value)
-   value_test(false, is_standard_fundamental<unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(false, is_standard_fundamental<__int64>::value)
-   value_test(false, is_standard_fundamental<unsigned __int64>::value)
-   #endif
-
-   value_test(false, is_arithmetic<UDT>::value)
-   value_test(true, is_arithmetic<char>::value)
-   value_test(true, is_arithmetic<signed char>::value)
-   value_test(true, is_arithmetic<unsigned char>::value)
-   value_test(true, is_arithmetic<wchar_t>::value)
-   value_test(true, is_arithmetic<short>::value)
-   value_test(true, is_arithmetic<unsigned short>::value)
-   value_test(true, is_arithmetic<int>::value)
-   value_test(true, is_arithmetic<unsigned int>::value)
-   value_test(true, is_arithmetic<long>::value)
-   value_test(true, is_arithmetic<unsigned long>::value)
-   value_test(true, is_arithmetic<float>::value)
-   value_test(true, is_arithmetic<double>::value)
-   value_test(true, is_arithmetic<long double>::value)
-   value_test(true, is_arithmetic<bool>::value)
-   #ifdef ULLONG_MAX
-   value_test(true, is_arithmetic<long long>::value)
-   value_test(true, is_arithmetic<unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(true, is_arithmetic<__int64>::value)
-   value_test(true, is_arithmetic<unsigned __int64>::value)
-   #endif
-
-   value_test(false, is_array<int>::value)
-   value_test(false, is_array<int*>::value)
-   value_test(true, is_array<int[2]>::value)
-   value_test(true, is_array<int[2][3]>::value)
-   value_test(true, is_array<UDT[2]>::value)
-
-   typedef void(*f1)();
-   typedef int(*f2)(int);
-   typedef int(*f3)(int, bool);
-   typedef void (UDT::*mf1)();
-   typedef int (UDT::*mf2)();
-   typedef int (UDT::*mf3)(int);
-   typedef int (UDT::*mf4)(int, float);
-
-   value_test(false, is_pointer<int>::value)
-   value_test(false, is_pointer<int&>::value)
-   value_test(true, is_pointer<int*>::value)
-   // Steve: was 'true', should be 'false', via 3.9.2p3, 3.9.3p1
-   value_test(false, is_pointer<int*const>::value)
-   // Steve: was 'true', should be 'false', via 3.9.2p3, 3.9.3p1
-   value_test(false, is_pointer<int*volatile>::value)
-   // Steve: was 'true', should be 'false', via 3.9.2p3, 3.9.3p1
-   value_test(false, is_pointer<int*const volatile>::value)
-   value_test(true, is_pointer<f1>::value)
-   value_test(true, is_pointer<f2>::value)
-   value_test(true, is_pointer<f3>::value)
-   // Steve: was 'true', should be 'false', via 3.9.2p3
-   value_test(false, is_pointer<mf1>::value)
-   // Steve: was 'true', should be 'false', via 3.9.2p3
-   value_test(false, is_pointer<mf2>::value)
-   // Steve: was 'true', should be 'false', via 3.9.2p3
-   value_test(false, is_pointer<mf3>::value)
-   // Steve: was 'true', should be 'false', via 3.9.2p3
-   value_test(false, is_pointer<mf4>::value)
-
-   value_test(false, is_reference<bool>::value)
-   value_test(true, is_reference<int&>::value)
-   value_test(true, is_reference<const int&>::value)
-   value_test(true, is_reference<volatile int &>::value)
-   value_test(true, is_reference<r_type>::value)
-   value_test(true, is_reference<cr_type>::value)
-
-   value_test(false, is_class<int>::value)
-   value_test(false, is_class<const int>::value)
-   value_test(false, is_class<volatile int>::value)
-   value_test(false, is_class<int*>::value)
-   value_test(false, is_class<int* const>::value)
-   value_test(false, is_class<int[2]>::value)
-   value_test(false, is_class<int&>::value)
-   value_test(false, is_class<mf4>::value)
-   value_test(false, is_class<f1>::value)
-   value_test(false, is_class<enum_UDT>::value)
-   value_test(true, is_class<UDT>::value)
-   value_test(true, is_class<UDT const>::value)
-   value_test(true, is_class<UDT volatile>::value)
-   value_test(true, is_class<empty_UDT>::value)
-   value_test(true, is_class<std::iostream>::value)
-   value_test(false, is_class<UDT*>::value)
-   value_test(false, is_class<UDT[2]>::value)
-   value_test(false, is_class<UDT&>::value)
-
-   value_test(true, is_object<int>::value)
-   value_test(true, is_object<UDT>::value)
-   value_test(false, is_object<int&>::value)
-   value_test(false, is_object<void>::value)
-   value_test(true, is_standard_scalar<int>::value)
-   value_test(true, is_extension_scalar<void*>::value)
-
-   value_test(false, is_enum<int>::value)
-   value_test(true, is_enum<enum_UDT>::value)
-
-   value_test(false, is_member_pointer<f1>::value)
-   value_test(false, is_member_pointer<f2>::value)
-   value_test(false, is_member_pointer<f3>::value)
-   value_test(true, is_member_pointer<mf1>::value)
-   value_test(true, is_member_pointer<mf2>::value)
-   value_test(true, is_member_pointer<mf3>::value)
-   value_test(true, is_member_pointer<mf4>::value)
-
-   value_test(false, is_empty<int>::value)
-   value_test(false, is_empty<int*>::value)
-   value_test(false, is_empty<int&>::value)
-   value_test(false, is_empty<int[2]>::value)
-   value_test(false, is_empty<f1>::value)
-   value_test(false, is_empty<mf1>::value)
-   value_test(false, is_empty<UDT>::value)
-   value_test(true, is_empty<empty_UDT>::value)
-   value_test(true, is_empty<empty_POD_UDT>::value)
-   value_test(true, is_empty<empty_union_UDT>::value)
-   value_test(false, is_empty<enum_UDT>::value)
-
-   value_test(true, has_trivial_constructor<int>::value)
-   value_test(true, has_trivial_constructor<int*>::value)
-   value_test(true, has_trivial_constructor<int*const>::value)
-   value_test(true, has_trivial_constructor<const int>::value)
-   value_test(true, has_trivial_constructor<volatile int>::value)
-   value_test(true, has_trivial_constructor<int[2]>::value)
-   value_test(true, has_trivial_constructor<int[3][2]>::value)
-   value_test(true, has_trivial_constructor<int[2][4][5][6][3]>::value)
-   value_test(true, has_trivial_constructor<f1>::value)
-   value_test(true, has_trivial_constructor<mf2>::value)
-   value_test(false, has_trivial_constructor<UDT>::value)
-   value_test(true, has_trivial_constructor<empty_UDT>::value)
-   value_test(true, has_trivial_constructor<enum_UDT>::value)
-
-   value_test(true, has_trivial_copy<int>::value)
-   value_test(true, has_trivial_copy<int*>::value)
-   value_test(true, has_trivial_copy<int*const>::value)
-   value_test(true, has_trivial_copy<const int>::value)
-   // Steve: was 'false' -- should be 'true' via 3.9p3, 3.9p10
-   value_test(true, has_trivial_copy<volatile int>::value)
-   value_test(true, has_trivial_copy<int[2]>::value)
-   value_test(true, has_trivial_copy<int[3][2]>::value)
-   value_test(true, has_trivial_copy<int[2][4][5][6][3]>::value)
-   value_test(true, has_trivial_copy<f1>::value)
-   value_test(true, has_trivial_copy<mf2>::value)
-   value_test(false, has_trivial_copy<UDT>::value)
-   value_test(true, has_trivial_copy<empty_UDT>::value)
-   value_test(true, has_trivial_copy<enum_UDT>::value)
-
-   value_test(true, has_trivial_assign<int>::value)
-   value_test(true, has_trivial_assign<int*>::value)
-   value_test(true, has_trivial_assign<int*const>::value)
-   value_test(true, has_trivial_assign<const int>::value)
-   // Steve: was 'false' -- should be 'true' via 3.9p3, 3.9p10
-   value_test(true, has_trivial_assign<volatile int>::value)
-   value_test(true, has_trivial_assign<int[2]>::value)
-   value_test(true, has_trivial_assign<int[3][2]>::value)
-   value_test(true, has_trivial_assign<int[2][4][5][6][3]>::value)
-   value_test(true, has_trivial_assign<f1>::value)
-   value_test(true, has_trivial_assign<mf2>::value)
-   value_test(false, has_trivial_assign<UDT>::value)
-   value_test(true, has_trivial_assign<empty_UDT>::value)
-   value_test(true, has_trivial_assign<enum_UDT>::value)
-
-   value_test(true, has_trivial_destructor<int>::value)
-   value_test(true, has_trivial_destructor<int*>::value)
-   value_test(true, has_trivial_destructor<int*const>::value)
-   value_test(true, has_trivial_destructor<const int>::value)
-   value_test(true, has_trivial_destructor<volatile int>::value)
-   value_test(true, has_trivial_destructor<int[2]>::value)
-   value_test(true, has_trivial_destructor<int[3][2]>::value)
-   value_test(true, has_trivial_destructor<int[2][4][5][6][3]>::value)
-   value_test(true, has_trivial_destructor<f1>::value)
-   value_test(true, has_trivial_destructor<mf2>::value)
-   value_test(false, has_trivial_destructor<UDT>::value)
-   value_test(false, has_trivial_destructor<empty_UDT>::value)
-   value_test(true, has_trivial_destructor<enum_UDT>::value)
-
-   value_test(true, is_POD<int>::value)
-   value_test(true, is_POD<int*>::value)
-   // Steve: was 'true', should be 'false', via 3.9p10
-   value_test(false, is_POD<int&>::value)
-   value_test(true, is_POD<int*const>::value)
-   value_test(true, is_POD<const int>::value)
-   // Steve: was 'false', should be 'true', via 3.9p10
-   value_test(true, is_POD<volatile int>::value)
-   // Steve: was 'true', should be 'false', via 3.9p10
-   value_test(false, is_POD<const int&>::value)
-   value_test(true, is_POD<int[2]>::value)
-   value_test(true, is_POD<int[3][2]>::value)
-   value_test(true, is_POD<int[2][4][5][6][3]>::value)
-   value_test(true, is_POD<f1>::value)
-   value_test(true, is_POD<mf2>::value)
-   value_test(false, is_POD<UDT>::value)
-   value_test(false, is_POD<empty_UDT>::value)
-   value_test(true, is_POD<enum_UDT>::value)
-
-   std::cout << std::endl << test_count << " tests completed (" << failures << " failures)... press any key to exit";
-   std::cin.get();
-   return failures;
-}
-
-
-
-