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

[SVN r18675]

include/boost/counting_iterator.hpp

@@ -4,7 +4,7 @@
 // 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 http://www.boost.org/libs/utility/counting_iterator.htm for documentation.
 //
 // Supplies:
 //
@@ -56,9 +56,7 @@
 # include <boost/type_traits.hpp>
 # include <boost/detail/numeric_traits.hpp>
 # include <boost/static_assert.hpp>
-# ifndef BOOST_NO_LIMITS
-#  include <limits>
-# endif
+# include <boost/limits.hpp>
 
 namespace boost {
 
@@ -135,7 +133,7 @@ namespace detail {
     // 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(ULLONG_MAX) || defined(ULONG_LONG_MAX)
+#  if defined(BOOST_HAS_LONG_LONG)
     BOOST_STATIC_CONSTANT(bool,
                           value = (
                               std::numeric_limits<T>::is_specialized
@@ -199,15 +197,20 @@ struct counting_iterator_policies : public default_iterator_policies
 template <class Incrementable>
 struct counting_iterator_generator
 {
-    typedef counting_iterator_traits<Incrementable> traits;
+    typedef typename boost::remove_const<
+        Incrementable
+    >::type value_type;
     
-    typedef iterator_adaptor<Incrementable,
-        counting_iterator_policies<Incrementable>,
-        Incrementable,
-        const Incrementable&,
-        const Incrementable*,
-        typename traits::iterator_category,
-        typename traits::difference_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;
 };
 

include/boost/half_open_range.hpp

@@ -99,17 +99,17 @@ struct half_open_range
 
  public:
     typedef iter_t const_iterator;
-    typedef typename counting_iterator_traits<Incrementable>::value_type value_type;
-    typedef typename counting_iterator_traits<Incrementable>::difference_type difference_type;
-    typedef typename counting_iterator_traits<Incrementable>::reference reference;
-    typedef typename counting_iterator_traits<Incrementable>::reference const_reference;
-    typedef typename counting_iterator_traits<Incrementable>::pointer pointer;
-    typedef typename counting_iterator_traits<Incrementable>::pointer const_pointer;
+    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 counting_iterator_traits<Incrementable>::difference_type size_type;
+    typedef typename iterator::difference_type size_type;
 
     half_open_range(Incrementable start, Incrementable finish)
         : m_start(start),

include/boost/iterator.hpp

@@ -5,7 +5,7 @@
 //  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 http://www.boost.org/libs/utility for documentation.
 
 //  Revision History
 //  12 Jan 01 added <cstddef> for std::ptrdiff_t (Jens Maurer)

include/boost/iterator_adaptors.hpp

@@ -9,9 +9,21 @@
 // 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/iterator_adaptors.htm for documentation.
+
 // Revision History:
 
+// 01 Feb 2002   Jeremy Siek
+//      Added more comments in default_iterator_policies.
+// 08 Jan 2001   David Abrahams
+//      Moved concept checks into a separate class, which makes MSVC
+//      better at dealing with them.
+// 07 Jan 2001   David Abrahams
+//      Choose proxy for operator->() only if the reference type is not a reference.
+//      Updated workarounds for __MWERKS__ == 0x2406
+// 20 Dec 2001   David Abrahams
+//      Adjusted is_convertible workarounds for __MWERKS__ == 0x2406
 // 03 Nov 2001   Jeremy Siek
 //      Changed the named template parameter interface and internal.
 // 04 Oct 2001   Jeremy Siek
@@ -111,17 +123,14 @@
 # include <boost/utility.hpp>
 # include <boost/compressed_pair.hpp>
 # include <boost/concept_check.hpp>
-# include <boost/type.hpp>
 # include <boost/static_assert.hpp>
 # include <boost/type_traits.hpp>
+# include <boost/type_traits/conversion_traits.hpp>
 # include <boost/detail/iterator.hpp>
 # include <boost/detail/select_type.hpp>
+# include <boost/detail/workaround.hpp>
 
-// I was having some problems with VC6. I couldn't tell whether our hack for
-// stock GCC was causing problems so I needed an easy way to turn it on and
-// off. Now we can test the hack with various compilers and still have an 
-// "out" if it doesn't work. -dwa 7/31/00
-# if __GNUC__ == 2 && __GNUC_MINOR__ <= 96 && !defined(__STL_USE_NAMESPACES)
+# if BOOST_WORKAROUND(__GNUC__, == 2) && __GNUC_MINOR__ <= 96 && !defined(__STL_USE_NAMESPACES)
 #  define BOOST_RELOPS_AMBIGUITY_BUG 1
 # endif
 
@@ -137,7 +146,7 @@ namespace boost {
 template <class Policies, class Adapted, class Traits>
 struct TrivialIteratorPoliciesConcept
 {
-  typedef typename Traits::reference Reference;
+  typedef typename Traits::reference reference;
   void constraints() {
     function_requires< AssignableConcept<Policies> >();
     function_requires< DefaultConstructibleConcept<Policies> >();
@@ -147,7 +156,7 @@ struct TrivialIteratorPoliciesConcept
     const_constraints();
   }
   void const_constraints() const {
-    Reference r = p.dereference(x);
+    reference r = p.dereference(x);
     b = p.equal(x, x);
     ignore_unused_variable_warning(r);
   }
@@ -163,7 +172,7 @@ struct ForwardIteratorPoliciesConcept
 {
   typedef typename Traits::iterator_category iterator_category;
   void constraints() {
-    function_requires< 
+    function_requires<
       TrivialIteratorPoliciesConcept<Policies, Adapted, Traits>
       >();
 
@@ -181,7 +190,7 @@ struct BidirectionalIteratorPoliciesConcept
 {
   typedef typename Traits::iterator_category iterator_category;
   void constraints() {
-    function_requires< 
+    function_requires<
       ForwardIteratorPoliciesConcept<Policies, Adapted, Traits>
       >();
 
@@ -199,7 +208,7 @@ struct RandomAccessIteratorPoliciesConcept
   typedef typename Traits::difference_type DifferenceType;
   typedef typename Traits::iterator_category iterator_category;
   void constraints() {
-    function_requires< 
+    function_requires<
       BidirectionalIteratorPoliciesConcept<Policies, Adapted, Traits>
       >();
 
@@ -223,9 +232,15 @@ struct RandomAccessIteratorPoliciesConcept
 // class if you want to customize particular policies.
 struct default_iterator_policies
 {
-    // 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.
+    // Some of the member functions were defined static, but Borland
+    // got confused and thought they were non-const. Also, Sun C++
+    // does not like static function templates. 
+    //
+    // The reason some members were defined static is because there is
+    // not state (data members) needed by those members of the
+    // default_iterator_policies class. If your policies class member
+    // functions need to access state stored in the policies object,
+    // then the member functions should not be static (they can't be).
 
     template <class Base>
     void initialize(Base&)
@@ -257,7 +272,7 @@ struct default_iterator_policies
         { return x.base() == y.base(); }
 };
 
-// putting the comparisons in a base class avoids the g++ 
+// putting the comparisons in a base class avoids the g++
 // ambiguous overload bug due to the relops operators
 
 #ifdef BOOST_RELOPS_AMBIGUITY_BUG
@@ -265,7 +280,7 @@ template <class Derived, class Base>
 struct iterator_comparisons : Base { };
 
 template <class D1, class D2, class Base1, class Base2>
-inline bool operator==(const iterator_comparisons<D1,Base1>& xb, 
+inline bool operator==(const iterator_comparisons<D1,Base1>& xb,
                        const iterator_comparisons<D2,Base2>& yb)
 {
         const D1& x = static_cast<const D1&>(xb);
@@ -274,7 +289,7 @@ inline bool operator==(const iterator_comparisons<D1,Base1>& xb,
 }
 
 template <class D1, class D2, class Base1, class Base2>
-inline bool operator!=(const iterator_comparisons<D1,Base1>& xb, 
+inline bool operator!=(const iterator_comparisons<D1,Base1>& xb,
                        const iterator_comparisons<D2,Base2>& yb)
 {
     const D1& x = static_cast<const D1&>(xb);
@@ -283,7 +298,7 @@ inline bool operator!=(const iterator_comparisons<D1,Base1>& xb,
 }
 
 template <class D1, class D2, class Base1, class Base2>
-inline bool operator<(const iterator_comparisons<D1,Base1>& xb, 
+inline bool operator<(const iterator_comparisons<D1,Base1>& xb,
                       const iterator_comparisons<D2,Base2>& yb)
 {
     const D1& x = static_cast<const D1&>(xb);
@@ -292,16 +307,16 @@ inline bool operator<(const iterator_comparisons<D1,Base1>& xb,
 }
 
 template <class D1, class D2, class Base1, class Base2>
-inline bool operator>(const iterator_comparisons<D1,Base1>& xb, 
+inline bool operator>(const iterator_comparisons<D1,Base1>& xb,
                       const iterator_comparisons<D2,Base2>& yb)
-{ 
+{
     const D1& x = static_cast<const D1&>(xb);
     const D2& y = static_cast<const D2&>(yb);
     return x.policies().distance(y, x) > 0;
 }
 
 template <class D1, class D2, class Base1, class Base2>
-inline bool operator>=(const iterator_comparisons<D1,Base1>& xb, 
+inline bool operator>=(const iterator_comparisons<D1,Base1>& xb,
                        const iterator_comparisons<D2,Base2>& yb)
 {
     const D1& x = static_cast<const D1&>(xb);
@@ -310,7 +325,7 @@ inline bool operator>=(const iterator_comparisons<D1,Base1>& xb,
 }
 
 template <class D1, class D2, class Base1, class Base2>
-inline bool operator<=(const iterator_comparisons<D1,Base1>& xb, 
+inline bool operator<=(const iterator_comparisons<D1,Base1>& xb,
                        const iterator_comparisons<D2,Base2>& yb)
 {
     const D1& x = static_cast<const D1&>(xb);
@@ -350,17 +365,14 @@ namespace detail {
     return &(*i);
   }
 
-  template <class Category, class Value, class Pointer>
+  template <class Value, class Reference, class Pointer>
   struct operator_arrow_result_generator
   {
       typedef operator_arrow_proxy<Value> proxy;
       // Borland chokes unless it's an actual enum (!)
-      enum { is_input_iter
-            = (boost::is_convertible<Category*,std::input_iterator_tag*>::value
-               & !boost::is_convertible<Category*,std::forward_iterator_tag*>::value)
-      };
-      
-      typedef typename boost::detail::if_true<(is_input_iter)>::template
+      enum { use_proxy = !boost::is_reference<Reference>::value };
+
+      typedef typename boost::detail::if_true<(use_proxy)>::template
       then<
         proxy,
    // else
@@ -369,7 +381,7 @@ namespace detail {
   };
 
 
-# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_STD_ITERATOR_TRAITS)
 
    // Select default pointer and reference types for adapted non-pointer
    // iterators based on the iterator and the value_type. Poor man's partial
@@ -422,14 +434,14 @@ namespace detail {
                 typename iterator_traits<Iterator>::pointer,
                 Value*
        >::type pointer;
-       
+
        typedef typename if_true<(
                ::boost::is_same<Value,typename iterator_traits<Iterator>::value_type>::value
            )>::template then<
                 typename iterator_traits<Iterator>::reference,
                 Value&
        >::type reference;
-       
+
    };
 # endif
 
@@ -478,8 +490,8 @@ namespace detail {
     template <class Base, class Traits>
     struct select {
       typedef typename Traits::value_type Value;
-      typedef typename boost::detail::iterator_defaults<Base,Value>::pointer 
-	type;
+      typedef typename boost::detail::iterator_defaults<Base,Value>::pointer
+        type;
     };
   };
   template <> struct default_generator<default_pointer>
@@ -489,8 +501,8 @@ namespace detail {
     template <class Base, class Traits>
     struct select {
       typedef typename Traits::value_type Value;
-      typedef typename boost::detail::iterator_defaults<Base,Value>::reference 
-	type;
+      typedef typename boost::detail::iterator_defaults<Base,Value>::reference
+        type;
     };
   };
   template <> struct default_generator<default_reference>
@@ -538,7 +550,7 @@ template <class Difference> struct difference_type_is
 {
   typedef detail::cons_type<detail::difference_type_tag, Difference> type;
 };
-template <class IteratorCategory> struct iterator_category_is 
+template <class IteratorCategory> struct iterator_category_is
   : public named_template_param_base
 {
   typedef detail::cons_type<detail::iterator_category_tag, IteratorCategory> type;
@@ -552,7 +564,7 @@ namespace detail {
   // An associative list is a list of key-value pairs. The list is
   // built out of cons_type's and is terminated by end_of_list.
 
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(__BORLANDC__)
+# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || BOOST_WORKAROUND(__BORLANDC__, != 0)
   template <class AssocList, class Key>
   struct find_param;
 
@@ -562,7 +574,7 @@ namespace detail {
       typedef typename Head::first_type Key1;
       typedef typename Head::second_type Value;
       typedef typename if_true<(is_same<Key1, Key2>::value)>::template
-      then<Value, 
+      then<Value,
         typename find_param<typename AssocList::second_type, Key2>::type
       >::type type;
     };
@@ -581,7 +593,7 @@ namespace detail {
     typedef typename find_param_helper1<AssocList>::type select1;
     typedef typename select1::template select<AssocList, Key>::type type;
   };
-#else
+# else
   template <class AssocList, class Key> struct find_param;
 
   template <class Key>
@@ -598,7 +610,7 @@ namespace detail {
   struct find_param<detail::cons_type< detail::cons_type<Key1, Value>, Rest>, Key2> {
     typedef typename find_param<Rest, Key2>::type type;
   };
-#endif
+# endif
 
   struct make_named_arg {
     template <class Key, class Value>
@@ -612,29 +624,29 @@ namespace detail {
   template <class Value>
   struct is_named_parameter
   {
-      enum { value = is_convertible<Value, named_template_param_base>::value };
+      enum { value = is_convertible< typename add_reference< Value >::type, add_reference< named_template_param_base >::type >::value };
   };
 
-#if defined(__MWERKS__) && __MWERKS__ <= 0x2405 // workaround for broken is_convertible implementation
+# if BOOST_WORKAROUND(__MWERKS__, <= 0x2407) // workaround for broken is_convertible implementation
   template <class T> struct is_named_parameter<value_type_is<T> > { enum { value = true }; };
   template <class T> struct is_named_parameter<reference_is<T> > { enum { value = true }; };
   template <class T> struct is_named_parameter<pointer_is<T> > { enum { value = true }; };
   template <class T> struct is_named_parameter<difference_type_is<T> > { enum { value = true }; };
   template <class T> struct is_named_parameter<iterator_category_is<T> > { enum { value = true }; };
-#endif
+# endif
 
   template <class Key, class Value>
   struct make_arg {
-#ifdef __BORLANDC__
+# if BOOST_WORKAROUND(__BORLANDC__, > 0)
     // Borland C++ doesn't like the extra indirection of is_named_parameter
-    typedef typename 
+    typedef typename
       if_true<(is_convertible<Value,named_template_param_base>::value)>::
       template then<make_named_arg, make_key_value>::type Make;
-#else
+# else
     enum { is_named = is_named_parameter<Value>::value };
     typedef typename if_true<(is_named)>::template
       then<make_named_arg, make_key_value>::type Make;
-#endif
+# endif
     typedef typename Make::template select<Key, Value>::type type;
   };
 
@@ -678,7 +690,7 @@ namespace detail {
   class iterator_adaptor_traits_gen
   {
     // Form an associative list out of the template parameters
-    // If the argument is a normal parameter (not named) then make_arg 
+    // If the argument is a normal parameter (not named) then make_arg
     // creates a key-value pair. If the argument is a named parameter,
     // then make_arg extracts the key-value pair defined inside the
     // named parameter.
@@ -703,9 +715,9 @@ namespace detail {
     typedef typename resolve_default<Val, default_value_type, Base, Traits0>::type
       value_type;
     // if getting default value type from iterator_traits, then it won't be const
-    typedef typename resolve_default<Diff, default_difference_type, Base, 
+    typedef typename resolve_default<Diff, default_difference_type, Base,
       Traits0>::type difference_type;
-    typedef typename resolve_default<Cat, default_iterator_category, Base, 
+    typedef typename resolve_default<Cat, default_iterator_category, Base,
       Traits0>::type iterator_category;
 
     typedef boost::iterator<iterator_category, value_type, difference_type,
@@ -718,26 +730,53 @@ namespace detail {
       pointer;
     typedef typename resolve_default<Ref, default_reference, Base, Traits1>::type
       reference;
-    
+
   public:
     typedef boost::iterator<iterator_category,
-      typename remove_const<value_type>::type, 
+      typename remove_const<value_type>::type,
       difference_type, pointer, reference> type;
   };
 
+  // This is really a partial concept check for iterators. Should it
+  // be moved or done differently?
+  template <class Category, class Value, class Difference, class Pointer, class Reference>
+  struct validator
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, is_input_or_output_iter
+          = (boost::is_convertible<Category*,std::input_iterator_tag*>::value
+             | boost::is_convertible<Category*,std::output_iterator_tag*>::value));
+
+      // Iterators should satisfy one of the known categories
+      BOOST_STATIC_ASSERT(is_input_or_output_iter);
+
+      // Iterators >= ForwardIterator must produce real references
+      // as required by the C++ standard requirements in Table 74.
+      BOOST_STATIC_CONSTANT(
+          bool, forward_iter_with_real_reference
+          = ((!boost::is_convertible<Category*,std::forward_iterator_tag*>::value)
+             | boost::is_same<Reference,Value&>::value
+             | boost::is_same<Reference,typename add_const<Value>::type&>::value));
+
+      BOOST_STATIC_ASSERT(forward_iter_with_real_reference);
+  };
+
+  template <class T, class Result> struct dependent
+  {
+    typedef Result type;
+  };
+
 } // namespace detail
 
 
 
 // This macro definition is only temporary in this file
-# if !defined(BOOST_MSVC)
+# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
 #  define BOOST_ARG_DEPENDENT_TYPENAME typename
 # else
 #  define BOOST_ARG_DEPENDENT_TYPENAME
 # endif
 
-template <class T> struct undefined;
-
 //============================================================================
 //iterator_adaptor - Adapts a generic piece of data as an iterator. Adaptation
 //      is especially easy if the data being adapted is itself an iterator
@@ -766,12 +805,12 @@ template <class T> struct undefined;
 //
 //   Distance - the difference_type of the resulting iterator. If not
 //      supplied, iterator_traits<Base>::difference_type is used.
-template <class Base, class Policies, 
-    class Value = detail::default_argument,
-    class Reference = detail::default_argument,
-    class Pointer = detail::default_argument,
-    class Category = detail::default_argument,
-    class Distance = detail::default_argument
+template <class Base, class Policies,
+    class Value = ::boost::detail::default_argument,
+    class Reference = ::boost::detail::default_argument,
+    class Pointer = ::boost::detail::default_argument,
+    class Category = ::boost::detail::default_argument,
+    class Distance = ::boost::detail::default_argument
          >
 struct iterator_adaptor :
 #ifdef BOOST_RELOPS_AMBIGUITY_BUG
@@ -798,32 +837,19 @@ struct iterator_adaptor :
     typedef Policies policies_type;
 
  private:
-    BOOST_STATIC_CONSTANT(bool, is_input_or_output_iter
-          = (boost::is_convertible<iterator_category*,std::input_iterator_tag*>::value
-             || boost::is_convertible<iterator_category*,std::output_iterator_tag*>::value));
-
-    // Iterators should satisfy one of the known categories
-    BOOST_STATIC_ASSERT(is_input_or_output_iter);
-
-#if !defined(BOOST_MSVC)
-    // Iterators >= ForwardIterator must produce real references
-    // as required by the C++ standard requirements in Table 74.
-    BOOST_STATIC_CONSTANT(bool, forward_iter_with_real_reference =
-           (!boost::is_convertible<iterator_category*,std::forward_iterator_tag*>::value
-           || boost::is_same<reference,value_type&>::value
-           || boost::is_same<reference,const value_type&>::value));
-    
-    // This check gives incorrect results in iter_traits_gen_test.cpp
-    BOOST_STATIC_ASSERT(forward_iter_with_real_reference);
-#endif
+    typedef detail::validator<
+        iterator_category,value_type,difference_type,pointer,reference
+        > concept_check;
 
  public:
-    iterator_adaptor() { }
+    iterator_adaptor()
+    {
+    }
 
     explicit
     iterator_adaptor(const Base& it, const Policies& p = Policies())
         : m_iter_p(it, p) {
-      policies().initialize(base());
+        policies().initialize(base());
     }
 
     template <class Iter2, class Value2, class Pointer2, class Reference2>
@@ -834,9 +860,9 @@ struct iterator_adaptor :
         policies().initialize(base());
     }
 
-#if defined(BOOST_MSVC) || defined(__BORLANDC__)
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(__BORLANDC__, > 0)
     // This is required to prevent a bug in how VC++ generates
-    // the assignment operator for compressed_pairv
+    // the assignment operator for compressed_pair
     iterator_adaptor& operator= (const iterator_adaptor& x) {
         m_iter_p = x.m_iter_p;
         return *this;
@@ -846,24 +872,25 @@ struct iterator_adaptor :
          return policies().dereference(*this);
     }
 
-#ifdef BOOST_MSVC
+#if BOOST_WORKAROUND(BOOST_MSVC, > 0)
 # pragma warning(push)
 # pragma warning( disable : 4284 )
 #endif
 
-    typename boost::detail::operator_arrow_result_generator<iterator_category,value_type,pointer>::type
+    typename boost::detail::operator_arrow_result_generator<value_type,reference,pointer>::type
     operator->() const
         { return detail::operator_arrow(*this, iterator_category()); }
 
-#ifdef BOOST_MSVC
+#if BOOST_WORKAROUND(BOOST_MSVC, > 0)
 # pragma warning(pop)
 #endif
 
-    value_type operator[](difference_type n) const
+    template <class diff_type>
+    typename detail::dependent<diff_type, value_type>::type operator[](diff_type n) const
         { return *(*this + n); }
-    
+
     self& operator++() {
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x2405
+#if !BOOST_WORKAROUND(__MWERKS__, <  0x2405)
         policies().increment(*this);
 #else
         // Odd bug, MWERKS couldn't  deduce the type for the member template
@@ -874,23 +901,23 @@ struct iterator_adaptor :
     }
 
     self operator++(int) { self tmp(*this); ++*this; return tmp; }
-    
+
     self& operator--() {
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x2405
+#if !BOOST_WORKAROUND(__MWERKS__, <  0x2405)
         policies().decrement(*this);
 #else
         policies().decrement<self>(*this);
 #endif
         return *this;
     }
-    
+
     self operator--(int) { self tmp(*this); --*this; return tmp; }
 
     self& operator+=(difference_type n) {
         policies().advance(*this, n);
         return *this;
     }
-  
+
     self& operator-=(difference_type n) {
         policies().advance(*this, -n);
         return *this;
@@ -948,7 +975,7 @@ operator-(
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
     class Reference1, class Reference2, class Pointer1, class Pointer2,
     class Category, class Distance>
-inline bool 
+inline bool
 operator==(
     const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
     const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
@@ -959,7 +986,7 @@ operator==(
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
     class Reference1, class Reference2, class Pointer1, class Pointer2,
     class Category, class Distance>
-inline bool 
+inline bool
 operator<(
     const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
     const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
@@ -970,18 +997,18 @@ operator<(
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
     class Reference1, class Reference2, class Pointer1, class Pointer2,
     class Category, class Distance>
-inline bool 
+inline bool
 operator>(
     const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
     const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
-{ 
+{
     return x.policies().distance(y, x) > 0;
 }
 
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
     class Reference1, class Reference2, class Pointer1, class Pointer2,
     class Category, class Distance>
-inline bool 
+inline bool
 operator>=(
     const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
     const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
@@ -992,7 +1019,7 @@ operator>=(
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
     class Reference1, class Reference2, class Pointer1, class Pointer2,
     class Category, class Distance>
-inline bool 
+inline bool
 operator<=(
     const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
     const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
@@ -1003,9 +1030,9 @@ operator<=(
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
     class Reference1, class Reference2, class Pointer1, class Pointer2,
     class Category, class Distance>
-inline bool 
+inline bool
 operator!=(
-    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x, 
+    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
     const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
 {
     return !x.policies().equal(x, y);
@@ -1023,7 +1050,7 @@ struct transform_iterator_policies : public default_iterator_policies
 {
     transform_iterator_policies() { }
     transform_iterator_policies(const AdaptableUnaryFunction& f) : m_f(f) { }
-    
+
     template <class IteratorAdaptor>
     typename IteratorAdaptor::reference
     dereference(const IteratorAdaptor& iter) const
@@ -1037,7 +1064,7 @@ class transform_iterator_generator
 {
     typedef typename AdaptableUnaryFunction::result_type value_type;
 public:
-    typedef iterator_adaptor<Iterator, 
+    typedef iterator_adaptor<Iterator,
       transform_iterator_policies<AdaptableUnaryFunction>,
         value_type, value_type, value_type*, std::input_iterator_tag>
       type;
@@ -1076,7 +1103,7 @@ struct indirect_iterator_policies : public default_iterator_policies
 };
 
 namespace detail {
-# if !defined(BOOST_MSVC) // stragely instantiated even when unused! Maybe try a recursive template someday ;-)
+# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) // strangely instantiated even when unused! Maybe try a recursive template someday ;-)
   template <class T>
   struct traits_of_value_type {
       typedef typename boost::detail::iterator_traits<T>::value_type outer_value;
@@ -1089,12 +1116,12 @@ namespace detail {
 
 template <class OuterIterator,      // Mutable or Immutable, does not matter
           class Value
-#if !defined(BOOST_MSVC)
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
                 = BOOST_ARG_DEPENDENT_TYPENAME detail::traits_of_value_type<
                         OuterIterator>::value_type
 #endif
-          , class Reference 
-#if !defined(BOOST_MSVC)
+          , class Reference
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
                 = BOOST_ARG_DEPENDENT_TYPENAME detail::traits_of_value_type<
                         OuterIterator>::reference
 #else
@@ -1102,8 +1129,8 @@ template <class OuterIterator,      // Mutable or Immutable, does not matter
 #endif
           , class Category = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<
                         OuterIterator>::iterator_category
-          , class Pointer 
-#if !defined(BOOST_MSVC)
+          , class Pointer
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
                 = BOOST_ARG_DEPENDENT_TYPENAME detail::traits_of_value_type<
                         OuterIterator>::pointer
 #else
@@ -1118,28 +1145,28 @@ struct indirect_iterator_generator
 
 template <class OuterIterator,      // Mutable or Immutable, does not matter
           class Value
-#if !defined(BOOST_MSVC)
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
                 = BOOST_ARG_DEPENDENT_TYPENAME detail::traits_of_value_type<
                         OuterIterator>::value_type
 #endif
-          , class Reference 
-#if !defined(BOOST_MSVC)
+          , class Reference
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
                 = BOOST_ARG_DEPENDENT_TYPENAME detail::traits_of_value_type<
                         OuterIterator>::reference
 #else
                 = Value &
 #endif
-          , class ConstReference = const Value&
+          , class ConstReference = Value const&
           , class Category = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<
                 OuterIterator>::iterator_category
-          , class Pointer 
-#if !defined(BOOST_MSVC)
+          , class Pointer
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
                 = BOOST_ARG_DEPENDENT_TYPENAME detail::traits_of_value_type<
                         OuterIterator>::pointer
 #else
                 = Value*
 #endif
-          , class ConstPointer = const Value*
+          , class ConstPointer = Value const*
            >
 struct indirect_iterator_pair_generator
 {
@@ -1149,7 +1176,7 @@ struct indirect_iterator_pair_generator
     Value, ConstReference,Category,ConstPointer>::type const_iterator;
 };
 
-#ifndef BOOST_MSVC
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
 template <class OuterIterator>
 inline typename indirect_iterator_generator<OuterIterator>::type
 make_indirect_iterator(OuterIterator base)
@@ -1168,29 +1195,29 @@ struct reverse_iterator_policies : public default_iterator_policies
     template <class IteratorAdaptor>
     typename IteratorAdaptor::reference dereference(const IteratorAdaptor& x) const
         { return *boost::prior(x.base()); }
-    
+
     template <class BidirectionalIterator>
     void increment(BidirectionalIterator& x) const
         { --x.base(); }
-    
+
     template <class BidirectionalIterator>
     void decrement(BidirectionalIterator& x) const
         { ++x.base(); }
-    
+
     template <class BidirectionalIterator, class DifferenceType>
     void advance(BidirectionalIterator& x, DifferenceType n) const
         { x.base() -= n; }
-    
+
     template <class Iterator1, class Iterator2>
     typename Iterator1::difference_type distance(
         const Iterator1& x, const Iterator2& y) const
         { return x.base() - y.base(); }
-    
+
     template <class Iterator1, class Iterator2>
     bool equal(const Iterator1& x, const Iterator2& y) const
         { return x.base() == y.base(); }
 };
-  
+
 template <class BidirectionalIterator,
     class Value = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<BidirectionalIterator>::value_type,
     class Reference = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_defaults<BidirectionalIterator,Value>::reference,
@@ -1226,7 +1253,7 @@ struct projection_iterator_policies : public default_iterator_policies
         return m_f(*iter.base());
     }
 
-    AdaptableUnaryFunction m_f;    
+    AdaptableUnaryFunction m_f;
 };
 
 template <class AdaptableUnaryFunction, class Iterator>
@@ -1255,7 +1282,7 @@ struct projection_iterator_pair_generator {
 template <class AdaptableUnaryFunction, class Iterator>
 inline typename projection_iterator_generator<AdaptableUnaryFunction, Iterator>::type
 make_projection_iterator(
-    Iterator iter, 
+    Iterator iter,
     const AdaptableUnaryFunction& f = AdaptableUnaryFunction())
 {
     typedef typename projection_iterator_generator<AdaptableUnaryFunction, Iterator>::type result_t;
@@ -1265,7 +1292,7 @@ make_projection_iterator(
 template <class AdaptableUnaryFunction, class Iterator>
 inline typename const_projection_iterator_generator<AdaptableUnaryFunction, Iterator>::type
 make_const_projection_iterator(
-    Iterator iter, 
+    Iterator iter,
     const AdaptableUnaryFunction& f = AdaptableUnaryFunction())
 {
     typedef typename const_projection_iterator_generator<AdaptableUnaryFunction, Iterator>::type result_t;
@@ -1281,7 +1308,7 @@ class filter_iterator_policies
 public:
     filter_iterator_policies() { }
 
-    filter_iterator_policies(const Predicate& p, const Iterator& end) 
+    filter_iterator_policies(const Predicate& p, const Iterator& end)
         : m_predicate(p), m_end(end) { }
 
     void initialize(Iterator& x) {
@@ -1335,7 +1362,7 @@ namespace detail {
   template <class Iterator>
   struct non_bidirectional_category
   {
-# if !defined(__MWERKS__) || __MWERKS__ > 0x2405
+# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
       typedef typename reduce_to_base_class<
               std::forward_iterator_tag,
                    typename iterator_traits<Iterator>::iterator_category
@@ -1361,7 +1388,7 @@ namespace detail {
   };
 }
 
-template <class Predicate, class Iterator, 
+template <class Predicate, class Iterator,
     class Value = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<Iterator>::value_type,
     class Reference = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_defaults<Iterator,Value>::reference,
     class Pointer = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_defaults<Iterator,Value>::pointer,
@@ -1371,7 +1398,7 @@ template <class Predicate, class Iterator,
 class filter_iterator_generator {
     BOOST_STATIC_CONSTANT(bool, is_bidirectional
         = (boost::is_convertible<Category*, std::bidirectional_iterator_tag*>::value));
-#ifndef BOOST_MSVC // I don't have any idea why this occurs, but it doesn't seem to hurt too badly.
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) // I don't have any idea why this occurs, but it doesn't seem to hurt too badly.
     BOOST_STATIC_ASSERT(!is_bidirectional);
 #endif
     typedef filter_iterator_policies<Predicate,Iterator> policies_type;

include/boost/pending/detail/int_iterator.hpp

@@ -1,75 +0,0 @@
-//  (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.
-
-#ifndef BOOST_INT_ITERATOR_H
-#define BOOST_INT_ITERATOR_H
-
-#include <boost/iterator.hpp>
-#if !defined BOOST_MSVC
-#include <boost/operators.hpp>
-#endif
-#include <iostream>
-//using namespace std;
-
-#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
-namespace boost {
-#endif
-
-// this should use random_access_iterator_helper but I've had
-// VC++ portablility problems with that. -JGS
-template <class IntT>
-class int_iterator
-{
-  typedef int_iterator self;
-public:
-  typedef std::random_access_iterator_tag iterator_category;
-  typedef IntT value_type;
-  typedef IntT& reference;
-  typedef IntT* pointer;
-  typedef std::ptrdiff_t difference_type;
-
-  inline int_iterator() : _i(0) { }
-  inline int_iterator(IntT i) : _i(i) { }
-  inline int_iterator(const self& x) : _i(x._i) { }
-  inline self& operator=(const self& x) { _i = x._i; return *this; }
-  inline IntT operator*() { return _i; }
-  inline IntT operator[](IntT n) { return _i + n; }
-  inline self& operator++() { ++_i; return *this; }
-  inline self operator++(int) { self t = *this; ++_i; return t; }
-  inline self& operator+=(IntT n) { _i += n; return *this; }
-  inline self operator+(IntT n) { self t = *this; t += n; return t; }
-  inline self& operator--() { --_i; return *this; }
-  inline self operator--(int) { self t = *this; --_i; return t; }
-  inline self& operator-=(IntT n) { _i -= n; return *this; }
-  inline IntT operator-(const self& x) const { return _i - x._i; }
-  inline bool operator==(const self& x) const { return _i == x._i; }
-  // vc++ had a problem finding != in random_access_iterator_helper
-  // need to look into this... for now implementing everything here -JGS
-  inline bool operator!=(const self& x) const { return _i != x._i; }
-  inline bool operator<(const self& x) const { return _i < x._i; }
-  inline bool operator<=(const self& x) const { return _i <= x._i; }
-  inline bool operator>(const self& x) const { return _i > x._i; }
-  inline bool operator>=(const self& x) const { return _i >= x._i; }
-protected:
-  IntT _i;
-};
-
-template <class IntT>
-inline int_iterator<IntT>
-operator+(IntT n, int_iterator<IntT> t) { t += n; return t; }
-
-#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
-} /* namespace boost */
-#endif
-
-#ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
-namespace boost {
-  using ::int_iterator;
-}
-#endif
-
-
-#endif /* BOOST_INT_ITERATOR_H */

include/boost/pending/integer_range.hpp

@@ -1,59 +0,0 @@
-// (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.
-//
-// Revision History:
-// 04 Jan 2001  Factored counting_iterator stuff into
-//              boost/counting_iterator.hpp (David Abrahams)
-
-#ifndef BOOST_INTEGER_RANGE_HPP_
-#define BOOST_INTEGER_RANGE_HPP_
-
-#include <boost/config.hpp>
-#include <boost/counting_iterator.hpp>
-
-namespace boost {
-
-//=============================================================================
-// Counting Iterator and Integer Range Class
-
-template <class IntegerType>
-struct integer_range {
-    typedef typename counting_iterator_generator<IntegerType>::type iterator;
-
-    typedef iterator const_iterator;
-    typedef IntegerType value_type;
-    typedef std::ptrdiff_t difference_type;
-    typedef IntegerType reference;
-    typedef IntegerType const_reference;
-    typedef const IntegerType* pointer;
-    typedef const IntegerType* const_pointer;
-    typedef IntegerType size_type;
-
-    integer_range(IntegerType start, IntegerType finish)
-        : m_start(start), m_finish(finish) { }
-
-    iterator begin() const { return iterator(m_start); }
-    iterator end() const { return iterator(m_finish); }
-    size_type size() const { return m_finish - m_start; }
-    bool empty() const { return m_finish == m_start; }
-    void swap(integer_range& x) {
-        std::swap(m_start, x.m_start);
-        std::swap(m_finish, x.m_finish);
-    }
-protected:
-    IntegerType m_start, m_finish;
-};
-
-template <class IntegerType>
-inline integer_range<IntegerType>
-make_integer_range(IntegerType first, IntegerType last)
-{
-  return integer_range<IntegerType>(first, last);
-}
-
-} // namespace boost
-
-#endif // BOOST_INTEGER_RANGE_HPP_

include/boost/pending/iterator_adaptors.hpp

@@ -1 +0,0 @@
-#include <boost/iterator_adaptors.hpp>

include/boost/pending/iterator_tests.hpp

@@ -1,214 +0,0 @@
-#ifndef BOOST_ITERATOR_TESTS_HPP
-# define BOOST_ITERATOR_TESTS_HPP
-
-// This is meant to be the beginnings of a comprehensive, generic
-// test suite for STL concepts such as iterators and containers.
-//
-// Revision History:
-// 08 Feb 2001  Fixed bidirectional iterator test so that
-//              --i is no longer a precondition.
-//              (Jeremy Siek)
-// 04 Feb 2001  Added lvalue test, corrected preconditions
-//              (David Abrahams)
-
-# include <iterator>
-# include <assert.h>
-# include <boost/type_traits.hpp>
-# include <boost/static_assert.hpp>
-# include <boost/concept_archetype.hpp> // for detail::dummy_constructor
-
-namespace boost {
-
-  // use this for the value type
-struct dummyT { 
-  dummyT() { }
-  dummyT(detail::dummy_constructor) { }
-  dummyT(int x) : m_x(x) { }
-  int foo() const { return m_x; } 
-  bool operator==(const dummyT& d) const { return m_x == d.m_x; }
-  int m_x;
-};
-
-
-// Tests whether type Iterator satisfies the requirements for a
-// TrivialIterator. 
-// Preconditions: i != j, *i == val
-template <class Iterator, class T>
-void trivial_iterator_test(const Iterator i, const Iterator j, T val)
-{
-  Iterator k;
-  assert(i == i);
-  assert(j == j);
-  assert(i != j);
-#ifdef BOOST_NO_STD_ITERATOR_TRAITS
-  T v = *i;
-#else
-  typename std::iterator_traits<Iterator>::value_type v = *i;
-#endif
-  assert(v == val);
-#if 0
-  // hmm, this will give a warning for transform_iterator...  perhaps
-  // this should be separated out into a stand-alone test since there
-  // are several situations where it can't be used, like for
-  // integer_range::iterator.
-  assert(v == i->foo());
-#endif
-  k = i;
-  assert(k == k);
-  assert(k == i);
-  assert(k != j);
-  assert(*k == val);
-}
-
-
-// Preconditions: i != j
-template <class Iterator, class T>
-void mutable_trivial_iterator_test(const Iterator i, const Iterator j, T val)
-{
-  *i = val;
-  trivial_iterator_test(i, j, val);
-}
-
-
-// Preconditions: *i == v1, *++i == v2
-template <class Iterator, class T>
-void input_iterator_test(Iterator i, T v1, T v2) 
-{
-  Iterator i1 = i, i2 = i;
-
-  assert(i == i1++);
-  assert(i != ++i2);
-
-  trivial_iterator_test(i, i1, v1);
-  trivial_iterator_test(i, i2, v1);
-
-  ++i;
-  assert(i == i1);
-  assert(i == i2);
-  ++i1;
-  ++i2;
-
-  trivial_iterator_test(i, i1, v2);
-  trivial_iterator_test(i, i2, v2);
-}
-
-// how to test output iterator?
-
-
-template <bool is_pointer> struct lvalue_test
-{
-    template <class Iterator> static void check(Iterator)
-    {
-# ifndef BOOST_NO_STD_ITERATOR_TRAITS
-        typedef typename std::iterator_traits<Iterator>::reference reference;
-        typedef typename std::iterator_traits<Iterator>::value_type value_type;
-# else
-        typedef typename Iterator::reference reference;
-        typedef typename Iterator::value_type value_type;
-# endif
-        BOOST_STATIC_ASSERT(boost::is_reference<reference>::value);
-        BOOST_STATIC_ASSERT((boost::is_same<reference,value_type&>::value
-                             || boost::is_same<reference,const value_type&>::value
-            ));
-    }
-};
-
-# ifdef BOOST_NO_STD_ITERATOR_TRAITS
-template <> struct lvalue_test<true> {
-    template <class T> static void check(T) {}
-};
-#endif
-
-template <class Iterator, class T>
-void forward_iterator_test(Iterator i, T v1, T v2) 
-{
-  input_iterator_test(i, v1, v2);
-
- // borland doesn't allow non-type template parameters
-# if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
-  lvalue_test<(boost::is_pointer<Iterator>::value)>::check(i);
-#endif
-}
-
-// Preconditions: *i == v1, *++i == v2
-template <class Iterator, class T>
-void bidirectional_iterator_test(Iterator i, T v1, T v2)
-{
-  forward_iterator_test(i, v1, v2);
-  ++i;
-
-  Iterator i1 = i, i2 = i;
-
-  assert(i == i1--);
-  assert(i != --i2);
-
-  trivial_iterator_test(i, i1, v2);
-  trivial_iterator_test(i, i2, v2);
-
-  --i;
-  assert(i == i1);
-  assert(i == i2);
-  ++i1;
-  ++i2;
-
-  trivial_iterator_test(i, i1, v1);
-  trivial_iterator_test(i, i2, v1);
-}
-
-// mutable_bidirectional_iterator_test
-
-// Preconditions: [i,i+N) is a valid range
-template <class Iterator, class TrueVals>
-void random_access_iterator_test(Iterator i, int N, TrueVals vals)
-{
-  bidirectional_iterator_test(i, vals[0], vals[1]);
-  const Iterator j = i;
-  int c;
-
-  for (c = 0; c < N-1; ++c) {
-    assert(i == j + c);
-    assert(*i == vals[c]);
-    assert(*i == j[c]);
-    assert(*i == *(j + c));
-    assert(*i == *(c + j));
-    ++i;
-    assert(i > j);
-    assert(i >= j);
-    assert(j <= i);
-    assert(j < i);
-  }
-
-  Iterator k = j + N - 1;
-  for (c = 0; c < N-1; ++c) {
-    assert(i == k - c);
-    assert(*i == vals[N - 1 - c]);
-    assert(*i == j[N - 1 - c]);
-    Iterator q = k - c; 
-    assert(*i == *q);
-    assert(i > j);
-    assert(i >= j);
-    assert(j <= i);
-    assert(j < i);
-    --i;
-  }
-}
-
-// Precondition: i != j
-template <class Iterator, class ConstIterator>
-void const_nonconst_iterator_test(Iterator i, ConstIterator j)
-{
-  assert(i != j);
-  assert(j != i);
-
-  ConstIterator k(i);
-  assert(k == i);
-  assert(i == k);
-
-  k = i;
-  assert(k == i);
-  assert(i == k);
-}
-
-} // namespace boost
-
-#endif // BOOST_ITERATOR_TESTS_HPP

include/boost/permutation_iterator.hpp

@@ -5,6 +5,11 @@
 // 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 {
@@ -64,3 +69,6 @@ namespace boost {
   }
 
 } // namespace boost
+
+#endif // boost_permutation_iterator_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