This commit was manufactured by cvs2svn to create branch 'mpl_v2_2'.

[SVN r18675]

include/boost/counting_iterator.hpp

@@ -0,0 +1,229 @@
+// (C) Copyright David Abrahams and Jeremy Siek 2000-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/libs/utility/counting_iterator.htm for documentation.
+//
+// Supplies:
+//
+//   template <class Incrementable> class counting_iterator_traits;
+//   template <class Incrementable> class counting_iterator_policies;
+//
+//     Iterator traits and policies for adapted iterators whose dereferenced
+//     value progresses through consecutive values of Incrementable when the
+//     iterator is derferenced.
+//
+//   template <class Incrementable> struct counting_iterator_generator;
+//
+//     A "type generator" whose nested type "type" is a counting iterator as
+//     described above.
+//
+//   template <class Incrementable>
+//     typename counting_iterator_generator<Incrementable>::type
+//     make_counting_iterator(Incrementable);
+//
+//     A function which produces an adapted counting iterator over values of
+//     Incrementable.
+// 
+// Revision History
+// 14 Feb 2001  Removed unnecessary typedefs from counting_iterator_traits
+//              (Jeremy Siek)
+// 11 Feb 2001  Use BOOST_STATIC_CONSTANT (Dave Abrahams)
+// 11 Feb 2001  Clean up after John Maddocks's (finally effective!) Borland
+//              fixes (David Abrahams).
+// 10 Feb 2001  Use new iterator_adaptor<> interface (David Abrahams)
+// 10 Feb 2001  Rolled in supposed Borland fixes from John Maddock, but not
+//              seeing any improvement yet (David Abrahams)
+// 09 Feb 2001  Factored out is_numeric computation. Borland still
+//              unhappy :( (David Abrahams)
+// 08 Feb 2001  Beginning of a failed attempt to appease Borland
+//              (David Abrahams)
+// 07 Feb 2001  rename counting_iterator() -> make_counting_iterator()
+//              (David Abrahams)        
+// 04 Feb 2001  Added counting_iterator_generator; updated comments
+//              (David Abrahams)
+// 24 Jan 2001  initial revision, based on Jeremy Siek's
+//              boost/pending/integer_range.hpp (David Abrahams)
+
+#ifndef BOOST_COUNTING_ITERATOR_HPP_DWA20000119
+# define BOOST_COUNTING_ITERATOR_HPP_DWA20000119
+
+# include <boost/config.hpp>
+# include <boost/detail/iterator.hpp>
+# include <boost/iterator_adaptors.hpp>
+# include <boost/type_traits.hpp>
+# include <boost/detail/numeric_traits.hpp>
+# include <boost/static_assert.hpp>
+# include <boost/limits.hpp>
+
+namespace boost {
+
+namespace detail {
+
+  // Template class counting_iterator_traits_select -- choose an
+  // iterator_category and difference_type for a counting_iterator at
+  // compile-time based on whether or not it wraps an integer or an iterator,
+  // using "poor man's partial specialization".
+  template <bool is_integer> struct counting_iterator_traits_select;
+
+  // Incrementable is an iterator type
+  template <>
+  struct counting_iterator_traits_select<false>
+  {
+      template <class Incrementable>
+      struct traits
+      {
+       private:
+          typedef boost::detail::iterator_traits<Incrementable> x;
+       public:
+          typedef typename x::iterator_category iterator_category;
+          typedef typename x::difference_type difference_type;
+      };
+  };
+
+  // Incrementable is a numeric type
+  template <>
+  struct counting_iterator_traits_select<true>
+  {
+      template <class Incrementable>
+      struct traits
+      {
+          typedef typename
+            boost::detail::numeric_traits<Incrementable>::difference_type
+          difference_type;
+          typedef std::random_access_iterator_tag iterator_category;
+      };
+  };
+
+  // Template class distance_policy_select -- choose a policy for computing the
+  // distance between counting_iterators at compile-time based on whether or not
+  // the iterator wraps an integer or an iterator, using "poor man's partial
+  // specialization".
+
+  template <bool is_integer> struct distance_policy_select;
+
+  // A policy for wrapped iterators
+  template <>
+  struct distance_policy_select<false>
+  {
+      template <class Distance, class Incrementable>
+      struct policy {
+          static Distance distance(Incrementable x, Incrementable y)
+              { return boost::detail::distance(x, y); }
+      };
+  };
+
+  // A policy for wrapped numbers
+  template <>
+  struct distance_policy_select<true>
+  {
+      template <class Distance, class Incrementable>
+      struct policy {
+          static Distance distance(Incrementable x, Incrementable y)
+              { return numeric_distance(x, y); }
+      };
+  };
+
+  // Try to detect numeric types at compile time in ways compatible with the
+  // limitations of the compiler and library.
+  template <class T>
+  struct is_numeric {
+    // For a while, this wasn't true, but we rely on it below. This is a regression assert.
+    BOOST_STATIC_ASSERT(::boost::is_integral<char>::value);
+# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+#  if defined(BOOST_HAS_LONG_LONG)
+    BOOST_STATIC_CONSTANT(bool,
+                          value = (
+                              std::numeric_limits<T>::is_specialized
+                              | boost::is_same<T,long long>::value
+                              | boost::is_same<T,unsigned long long>::value));
+#  else
+     BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<T>::is_specialized);
+#  endif
+# else
+#  if !defined(__BORLANDC__)
+    BOOST_STATIC_CONSTANT(bool, value = (
+        boost::is_convertible<int,T>::value && boost::is_convertible<T,int>::value));
+#  else
+    BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
+#  endif
+# endif
+  };
+
+  // Compute the distance over arbitrary numeric and/or iterator types
+  template <class Distance, class Incrementable>
+  Distance any_distance(Incrementable start, Incrementable finish, Distance* = 0)
+  {
+    
+      return distance_policy_select<(
+          is_numeric<Incrementable>::value)>::template
+          policy<Distance, Incrementable>::distance(start, finish);
+  }
+  
+} // namespace detail
+
+template <class Incrementable>
+struct counting_iterator_traits {
+ private:
+    typedef ::boost::detail::counting_iterator_traits_select<(
+        ::boost::detail::is_numeric<Incrementable>::value
+        )> binder;
+    typedef typename binder::template traits<Incrementable> traits;
+ public:
+    typedef typename traits::difference_type difference_type;
+    typedef typename traits::iterator_category iterator_category;
+};
+
+template <class Incrementable>
+struct counting_iterator_policies : public default_iterator_policies
+{
+    template <class IteratorAdaptor>
+    typename IteratorAdaptor::reference dereference(const IteratorAdaptor& i) const
+        { return i.base(); }
+    
+    template <class Iterator1, class Iterator2>
+    typename Iterator1::difference_type distance(
+        const Iterator1& x, const Iterator2& y) const
+    {
+        typedef typename Iterator1::difference_type difference_type;
+        return boost::detail::any_distance<difference_type>(
+            x.base(), y.base());
+    }
+};
+
+// A type generator for counting iterators
+template <class Incrementable>
+struct counting_iterator_generator
+{
+    typedef typename boost::remove_const<
+        Incrementable
+    >::type value_type;
+    
+    typedef counting_iterator_traits<value_type> traits;
+    
+    typedef iterator_adaptor<
+        value_type
+        , counting_iterator_policies<value_type>
+        , value_type
+        , value_type const&
+        , value_type const*
+        , typename traits::iterator_category
+        , typename traits::difference_type
+    > type;
+};
+
+// Manufacture a counting iterator for an arbitrary incrementable type
+template <class Incrementable>
+inline typename counting_iterator_generator<Incrementable>::type
+make_counting_iterator(Incrementable x)
+{
+  typedef typename counting_iterator_generator<Incrementable>::type result_t;
+  return result_t(x);
+}
+
+
+} // namespace boost
+
+#endif // BOOST_COUNTING_ITERATOR_HPP_DWA20000119

include/boost/function_output_iterator.hpp

@@ -0,0 +1,55 @@
+// (C) Copyright Jeremy Siek 2001. Permission to copy, use, modify,
+// sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+// Revision History:
+
+// 27 Feb 2001   Jeremy Siek
+//      Initial checkin.
+
+#ifndef BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
+#define BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
+
+#include <iterator>
+
+namespace boost {
+
+  template <class UnaryFunction>
+  class function_output_iterator {
+    typedef function_output_iterator self;
+  public:
+    typedef std::output_iterator_tag iterator_category;
+    typedef void                value_type;
+    typedef void                difference_type;
+    typedef void                pointer;
+    typedef void                reference;
+
+    explicit function_output_iterator(const UnaryFunction& f = UnaryFunction())
+      : m_f(f) {}
+
+    struct output_proxy {
+      output_proxy(UnaryFunction& f) : m_f(f) { }
+      template <class T> output_proxy& operator=(const T& value) {
+        m_f(value); 
+        return *this; 
+      }
+      UnaryFunction& m_f;
+    };
+    output_proxy operator*() { return output_proxy(m_f); }
+    self& operator++() { return *this; } 
+    self& operator++(int) { return *this; }
+  private:
+    UnaryFunction m_f;
+  };
+
+  template <class UnaryFunction>
+  inline function_output_iterator<UnaryFunction>
+  make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) {
+    return function_output_iterator<UnaryFunction>(f);
+  }
+
+} // namespace boost
+
+#endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP

include/boost/half_open_range.hpp

@@ -0,0 +1,426 @@
+// (C) Copyright Jeremy Siek and David Abrahams 2000-2001. Permission to copy,
+// use, modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided "as is"
+// without express or implied warranty, and with no claim as to its suitability
+// for any purpose.
+//
+// Revision History:
+// 11 Feb 2001  Use new iterator_adaptor interface, Fixes for Borland.
+//              (Dave Abrahams)
+// 04 Feb 2001  Support for user-defined iterator categories (Dave Abrahams)
+// 30 Jan 2001  Initial Checkin (Dave Abrahams)
+
+#ifndef BOOST_HALF_OPEN_RANGE_HPP_
+# define BOOST_HALF_OPEN_RANGE_HPP_
+
+# include <boost/counting_iterator.hpp>
+# include <functional>
+# include <cassert>
+# include <boost/operators.hpp>
+# include <string>
+# include <stdexcept>
+# include <iterator>
+
+namespace boost {
+
+namespace detail {
+
+  // Template class choose_finish -- allows us to maintain the invariant that
+  // start() <= finish() on half_open_range specializations that support random
+  // access.
+#ifdef __MWERKS__
+  template <class T>
+  const T& choose_finish(const T&, const T& finish, std::input_iterator_tag)
+  {
+      return finish;
+  }
+
+  template <class T>
+  const T& choose_finish(const T&, const T& finish, std::output_iterator_tag)
+  {
+      return finish;
+  }
+
+  template <class T>
+  const T& choose_finish(const T& start, const T& finish, std::random_access_iterator_tag)
+  {
+      return finish < start ? start : finish;
+  }
+#else
+  template <bool is_random_access> struct finish_chooser;
+
+  template <>
+  struct finish_chooser<false>
+  {
+      template <class T>
+      struct rebind
+      {
+          static T choose(const T&, const T& finish)
+              { return finish; }
+      };
+  };
+
+  template <>
+  struct finish_chooser<true>
+  {
+      template <class T>
+      struct rebind
+      {
+          static T choose(const T& start, const T& finish)
+              { return finish < start ? start : finish; }
+      };
+  };
+
+  template <class Category, class Incrementable>
+  struct choose_finish
+  {
+      static const Incrementable choose(const Incrementable& start, const Incrementable& finish)
+      {
+          return finish_chooser<(
+              ::boost::is_convertible<Category*,std::random_access_iterator_tag*>::value
+              )>::template rebind<Incrementable>::choose(start, finish);
+      }
+  };
+#endif
+}
+
+template <class Incrementable>
+struct half_open_range
+{
+    typedef typename counting_iterator_generator<Incrementable>::type iterator;
+
+ private: // utility type definitions
+    // Using iter_t prevents compiler confusion with boost::iterator
+    typedef typename counting_iterator_generator<Incrementable>::type iter_t;
+
+    typedef std::less<Incrementable> less_value;
+    typedef typename iter_t::iterator_category category;
+    typedef half_open_range<Incrementable> self;
+
+ public:
+    typedef iter_t const_iterator;
+    typedef typename iterator::value_type value_type;
+    typedef typename iterator::difference_type difference_type;
+    typedef typename iterator::reference reference;
+    typedef typename iterator::reference const_reference;
+    typedef typename iterator::pointer pointer;
+    typedef typename iterator::pointer const_pointer;
+    
+    // It would be nice to select an unsigned type, but this is appropriate
+    // since the library makes an attempt to select a difference_type which can
+    // hold the difference between any two iterators.
+    typedef typename iterator::difference_type size_type;
+
+    half_open_range(Incrementable start, Incrementable finish)
+        : m_start(start),
+          m_finish(
+#ifndef __MWERKS__
+            detail::choose_finish<category,Incrementable>::choose(start, finish)
+#else
+            detail::choose_finish(start, finish, category())
+#endif
+              )
+        {}
+
+    // Implicit conversion from std::pair<Incrementable,Incrementable> allows us
+    // to accept the results of std::equal_range(), for example.
+    half_open_range(const std::pair<Incrementable,Incrementable>& x)
+        : m_start(x.first),
+          m_finish(
+#ifndef __MWERKS__
+              detail::choose_finish<category,Incrementable>::choose(x.first, x.second)
+#else
+            detail::choose_finish(x.first, x.second, category())
+#endif
+              )
+        {}
+
+    half_open_range& operator=(const self& x)
+    {
+        m_start = x.m_start;
+        m_finish = x.m_finish;
+        return *this;
+    }
+    
+    half_open_range& operator=(const std::pair<Incrementable,Incrementable>& x)
+    {
+        m_start = x.first;
+        m_finish =
+#ifndef __MWERKS__
+            detail::choose_finish<category,Incrementable>::choose(x.first, x.second);
+#else
+            detail::choose_finish(x.first, x.second, category();
+#endif
+    }
+        
+    iterator begin() const { return iterator(m_start); }
+    iterator end() const { return iterator(m_finish); }
+    
+    Incrementable front() const { assert(!this->empty()); return m_start; }
+    Incrementable back() const { assert(!this->empty()); return boost::prior(m_finish); }
+                                     
+    Incrementable start() const { return m_start; }
+    Incrementable finish() const { return m_finish; }
+    
+    size_type size() const { return boost::detail::distance(begin(), end()); }
+
+    bool empty() const
+    {
+        return m_finish == m_start;
+    }
+
+    void swap(half_open_range& x) {
+        std::swap(m_start, x.m_start);
+        std::swap(m_finish, x.m_finish);
+    }
+    
+ public: // functions requiring random access elements
+    
+    // REQUIRES: x is reachable from this->front()
+    bool contains(const value_type& x) const
+    {
+        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
+        return !less_value()(x, m_start) && less_value()(x, m_finish);
+    }
+
+    bool contains(const half_open_range& x) const
+    {
+        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
+        return x.empty() || !less_value()(x.m_start, m_start) && !less_value()(m_finish, x.m_finish);
+    }
+
+    bool intersects(const half_open_range& x) const
+    {
+        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
+        return less_value()(
+            less_value()(this->m_start, x.m_start) ? x.m_start : this->m_start,
+            less_value()(this->m_finish, x.m_finish) ? this->m_finish : x.m_finish);
+    }
+
+    half_open_range& operator&=(const half_open_range& x)
+    {
+        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
+        
+        if (less_value()(this->m_start, x.m_start))
+            this->m_start = x.m_start;
+        
+        if (less_value()(x.m_finish, this->m_finish))
+            this->m_finish = x.m_finish;
+
+        if (less_value()(this->m_finish, this->m_start))
+            this->m_start = this->m_finish;
+
+        return *this;
+    }
+
+    half_open_range& operator|=(const half_open_range& x)
+    {
+        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
+
+        if (!x.empty())
+        {
+            if (this->empty())
+            {
+                *this = x;
+            }
+            else
+            {
+                if (less_value()(x.m_start, this->m_start))
+                    this->m_start = x.m_start;
+        
+                if (less_value()(this->m_finish, x.m_finish))
+                    this->m_finish = x.m_finish;
+            }
+        }
+        return *this;
+    }
+
+    // REQUIRES: x is reachable from this->front()
+    const_iterator find(const value_type& x) const
+    {
+        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
+        
+        return const_iterator(this->contains(x) ? x : m_finish);
+    }
+
+    // REQUIRES: index >= 0 && index < size()
+    value_type operator[](size_type index) const
+    {
+        assert(index >= 0 && index < size());
+        return m_start + index;
+    }
+    
+    value_type at(size_type index) const
+    {
+        if (index < 0 || index >= size())
+            throw std::out_of_range(std::string("half_open_range"));
+        return m_start + index;
+    }
+    
+ private: // data members
+    Incrementable m_start, m_finish;
+};
+
+template <class Incrementable>
+half_open_range<Incrementable> operator|(
+    half_open_range<Incrementable> x,
+    const half_open_range<Incrementable>& y)
+{
+    return x |= y;
+}
+
+template <class Incrementable>
+half_open_range<Incrementable> operator&(
+    half_open_range<Incrementable> x,
+    const half_open_range<Incrementable>& y)
+{
+    return x &= y;
+}
+
+template <class Incrementable>
+inline bool operator==(
+    const half_open_range<Incrementable>& x,
+    const half_open_range<Incrementable>& y)
+{
+    const bool y_empty = y.empty();
+    return x.empty() ? y_empty : !y_empty && x.start() == y.start() && x.finish() == y.finish();
+}
+
+template <class Incrementable>
+inline bool operator!=(
+    const half_open_range<Incrementable>& x,
+    const half_open_range<Incrementable>& y)
+{
+    return !(x == y);
+}
+
+template <class Incrementable>
+inline half_open_range<Incrementable>
+make_half_open_range(Incrementable first, Incrementable last)
+{
+  return half_open_range<Incrementable>(first, last);
+}
+
+template <class Incrementable>
+bool intersects(
+    const half_open_range<Incrementable>& x,
+    const half_open_range<Incrementable>& y)
+{
+    return x.intersects(y);
+}
+    
+template <class Incrementable>
+bool contains(
+    const half_open_range<Incrementable>& x,
+    const half_open_range<Incrementable>& y)
+{
+    return x.contains(y);
+}
+    
+} // namespace boost
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+namespace std {
+template <class Incrementable> struct less<boost::half_open_range<Incrementable> >
+        : binary_function<
+            boost::half_open_range<Incrementable>,
+            boost::half_open_range<Incrementable>,bool>
+{
+    bool operator()(
+        const boost::half_open_range<Incrementable>& x,
+        const boost::half_open_range<Incrementable>& y) const
+    {
+        less<Incrementable> cmp;
+        return !y.empty() && (
+            cmp(x.start(), y.start())
+            || !cmp(y.start(), x.start())
+               && cmp(x.finish(), y.finish()));
+    }
+};
+
+template <class Incrementable> struct less_equal<boost::half_open_range<Incrementable> >
+        : binary_function<
+            boost::half_open_range<Incrementable>,
+            boost::half_open_range<Incrementable>,bool>
+{
+    bool operator()(
+        const boost::half_open_range<Incrementable>& x,
+        const boost::half_open_range<Incrementable>& y) const
+    {
+        typedef boost::half_open_range<Incrementable> range;
+        less<range> cmp;
+        return !cmp(y,x);
+    }
+};
+template <class Incrementable> struct greater<boost::half_open_range<Incrementable> >
+        : binary_function<
+            boost::half_open_range<Incrementable>,
+            boost::half_open_range<Incrementable>,bool>
+{
+    bool operator()(
+        const boost::half_open_range<Incrementable>& x,
+        const boost::half_open_range<Incrementable>& y) const
+    {
+        typedef boost::half_open_range<Incrementable> range;
+        less<range> cmp;
+        return cmp(y,x);
+    }
+};
+
+template <class Incrementable> struct greater_equal<boost::half_open_range<Incrementable> >
+        : binary_function<
+            boost::half_open_range<Incrementable>,
+            boost::half_open_range<Incrementable>,bool>
+{
+    bool operator()(
+        const boost::half_open_range<Incrementable>& x,
+        const boost::half_open_range<Incrementable>& y) const
+    {
+        typedef boost::half_open_range<Incrementable> range;
+        less<range> cmp;
+        return !cmp(x,y);
+    }
+};
+} // namespace std
+
+#else
+
+namespace boost {
+// Can't partially specialize std::less et al, so we must provide the operators
+template <class Incrementable>
+bool operator<(const half_open_range<Incrementable>& x,
+               const half_open_range<Incrementable>& y)
+{
+    return !y.empty() && (
+        x.empty() || std::less<Incrementable>()(x.start(), y.start())
+        || !std::less<Incrementable>()(y.start(), x.start())
+                && std::less<Incrementable>()(x.finish(), y.finish()));
+}
+
+template <class Incrementable>
+bool operator>(const half_open_range<Incrementable>& x,
+               const half_open_range<Incrementable>& y)
+{
+    return y < x;
+}
+
+template <class Incrementable>
+bool operator<=(const half_open_range<Incrementable>& x,
+               const half_open_range<Incrementable>& y)
+{
+    return !(y < x);
+}
+
+template <class Incrementable>
+bool operator>=(const half_open_range<Incrementable>& x,
+               const half_open_range<Incrementable>& y)
+{
+    return !(x < y);
+}
+} // namespace boost
+
+#endif
+    
+
+#endif // BOOST_HALF_OPEN_RANGE_HPP_

include/boost/iterator.hpp

@@ -0,0 +1,60 @@
+//  interator.hpp workarounds for non-conforming standard libraries  ---------//
+
+//  (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/libs/utility for documentation.
+
+//  Revision History
+//  12 Jan 01 added <cstddef> for std::ptrdiff_t (Jens Maurer)
+//  28 Jun 00 Workarounds to deal with known MSVC bugs (David Abrahams)
+//  26 Jun 00 Initial version (Jeremy Siek)
+
+#ifndef BOOST_ITERATOR_HPP
+#define BOOST_ITERATOR_HPP
+
+#include <iterator>
+#include <cstddef>           // std::ptrdiff_t
+#include <boost/config.hpp>
+
+namespace boost
+{
+# if defined(BOOST_NO_STD_ITERATOR) && !defined(BOOST_MSVC_STD_ITERATOR)
+  template <class Category, class T,
+    class Distance = std::ptrdiff_t,
+    class Pointer = T*, class Reference = T&>
+  struct iterator
+  {
+    typedef T         value_type;
+    typedef Distance  difference_type;
+    typedef Pointer   pointer;
+    typedef Reference reference;
+    typedef Category  iterator_category;
+  };
+# else
+
+  // declare iterator_base in namespace detail to work around MSVC bugs which
+  // prevent derivation from an identically-named class in a different namespace.
+  namespace detail {
+   template <class Category, class T, class Distance, class Pointer, class Reference>
+#  if !defined(BOOST_MSVC_STD_ITERATOR)
+   struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
+#  else
+   struct iterator_base : std::iterator<Category, T, Distance>
+   {
+     typedef Reference reference;
+     typedef Pointer pointer;
+     typedef Distance difference_type;
+   };
+#  endif
+  }
+
+  template <class Category, class T, class Distance = std::ptrdiff_t,
+            class Pointer = T*, class Reference = T&>
+   struct iterator : detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
+# endif
+} // namespace boost
+
+#endif // BOOST_ITERATOR_HPP

include/boost/permutation_iterator.hpp

@@ -0,0 +1,74 @@
+// (C) Copyright Toon Knapen 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/libs/utility/permutation_iterator.htm for documentation.
+
+#ifndef boost_permutation_iterator_hpp
+#define boost_permutation_iterator_hpp
+
+#include <boost/iterator_adaptors.hpp>
+
+namespace boost {
+
+  template < typename IndexIterator >
+  struct permutation_iterator_policies : public default_iterator_policies
+  {
+    permutation_iterator_policies() {}
+
+    permutation_iterator_policies(IndexIterator order_it) 
+      : order_it_( order_it ) 
+    {}
+
+    template <class IteratorAdaptor>
+    typename IteratorAdaptor::reference dereference(const IteratorAdaptor& x) const
+    { return *(x.base() + *order_it_); }
+
+    template <class IteratorAdaptor>
+    void increment(IteratorAdaptor&)
+    { ++order_it_; }
+
+    template <class IteratorAdaptor>
+    void decrement(IteratorAdaptor&)
+    { --order_it_; }
+
+    template <class IteratorAdaptor, class DifferenceType>
+    void advance(IteratorAdaptor& x, DifferenceType n)
+    { std::advance( order_it_, n ); }
+
+    template <class IteratorAdaptor1, class IteratorAdaptor2>
+    typename IteratorAdaptor1::difference_type
+    distance(const IteratorAdaptor1& x, const IteratorAdaptor2& y) const
+    { return std::distance( x.policies().order_it_, y.policies().order_it_ ); }
+
+    template <class IteratorAdaptor1, class IteratorAdaptor2>
+    bool equal(const IteratorAdaptor1& x, const IteratorAdaptor2& y) const
+    { return x.policies().order_it_ == y.policies().order_it_; }
+  
+    IndexIterator order_it_;
+  };
+
+  template < typename ElementIterator, typename IndexIterator >
+  struct permutation_iterator_generator
+  {
+    typedef boost::iterator_adaptor
+    < ElementIterator,
+      permutation_iterator_policies< IndexIterator > 
+    > type;
+  };
+
+  template < class IndexIterator, class ElementIterator >
+  inline typename permutation_iterator_generator< ElementIterator, IndexIterator >::type
+  make_permutation_iterator(ElementIterator base, IndexIterator order)
+  {
+    typedef typename permutation_iterator_generator< ElementIterator, IndexIterator >::type result_t;
+    return result_t( base, order );
+  }
+
+} // namespace boost
+
+#endif // boost_permutation_iterator_hpp
+

include/boost/pointee.hpp

@@ -1,68 +0,0 @@
-// Copyright David Abrahams 2004. Use, modification and distribution is
-// subject to the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef POINTEE_DWA200415_HPP
-# define POINTEE_DWA200415_HPP
-
-// dereferenceable_traits provides access to the value_type and
-// reference of a Dereferenceable type.
-
-# include <boost/detail/is_incrementable.hpp>
-# include <boost/iterator/iterator_traits.hpp>
-# include <boost/type_traits/add_const.hpp>
-# include <boost/type_traits/remove_cv.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/apply_if.hpp>
-
-namespace boost { 
-
-namespace detail
-{
-  template <class P>
-  struct smart_ptr_pointee
-  {
-      typedef typename P::element_type type;
-  };
-
-  template <class Iterator>
-  struct iterator_pointee
-  {
-      typedef typename iterator_traits<Iterator>::value_type value_type;
-      
-      struct impl
-      {
-          template <class T>
-          static char test(T const&);
-          
-          static char (& test(value_type&) )[2];
-          
-          static Iterator& x;
-      };
-      
-      BOOST_STATIC_CONSTANT(bool, is_constant = sizeof(impl::test(*impl::x)) == 1);
-      
-      typedef typename mpl::if_c<
-#  if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-          ::boost::detail::iterator_pointee<Iterator>::is_constant
-#  else
-          is_constant
-#  endif 
-        , typename add_const<value_type>::type
-        , value_type
-      >::type type;
-  };
-}
-
-template <class P>
-struct pointee
-  : mpl::apply_if<
-        detail::is_incrementable<P>
-      , detail::iterator_pointee<P>
-      , detail::smart_ptr_pointee<P>
-    >
-{
-};
-  
-} // namespace boost
-
-#endif // POINTEE_DWA200415_HPP

include/boost/shared_container_iterator.hpp

@@ -0,0 +1,59 @@
+// (C) Copyright Ronald Garcia 2002. 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/libs/utility/shared_container_iterator.html for documentation.
+
+#ifndef SHARED_CONTAINER_ITERATOR_RG08102002_HPP
+#define SHARED_CONTAINER_ITERATOR_RG08102002_HPP
+
+#include "boost/iterator_adaptors.hpp"
+#include "boost/shared_ptr.hpp"
+#include <utility>
+
+namespace boost {
+
+template <typename Container>
+struct shared_container_iterator_policies :
+  public boost::default_iterator_policies {
+  typedef boost::shared_ptr<Container> container_ref_t;
+  container_ref_t container_ref;
+  shared_container_iterator_policies(container_ref_t const& c) :
+    container_ref(c) { }
+  shared_container_iterator_policies() { }
+};
+
+
+template <typename Container>
+class shared_container_iterator_generator {
+  typedef typename Container::iterator iterator;
+  typedef shared_container_iterator_policies<Container> policy;
+public:
+  typedef boost::iterator_adaptor<iterator,policy> type;
+};
+
+template <typename Container>
+typename shared_container_iterator_generator<Container>::type
+make_shared_container_iterator(typename Container::iterator iter,
+			       boost::shared_ptr<Container> const& container) {
+  typedef typename shared_container_iterator_generator<Container>::type
+    iterator;
+  typedef shared_container_iterator_policies<Container> policy;
+  return iterator(iter,policy(container));
+}
+
+template <typename Container>
+std::pair<
+  typename shared_container_iterator_generator<Container>::type,
+  typename shared_container_iterator_generator<Container>::type>
+make_shared_container_range(boost::shared_ptr<Container> const& container) {
+  return
+    std::make_pair(
+      make_shared_container_iterator(container->begin(),container),
+      make_shared_container_iterator(container->end(),container));
+}
+
+
+} // namespace boost
+#endif  // SHARED_CONTAINER_ITERATOR_RG08102002_HPP