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

[SVN r23968]

include/boost/function_output_iterator.hpp

@@ -1,7 +1,8 @@
-// (C) Copyright Jeremy Siek 2001.
-// Distributed under 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)
+// (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:
 

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

@@ -1,8 +1,9 @@
 //  interator.hpp workarounds for non-conforming standard libraries  ---------//
 
-//  (C) Copyright Beman Dawes 2000. Distributed under 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)
+//  (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.
 
@@ -52,7 +53,7 @@ namespace boost
 
   template <class Category, class T, class Distance = std::ptrdiff_t,
             class Pointer = T*, class Reference = T&>
-  struct iterator : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
+   struct iterator : detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
 # endif
 } // namespace boost
 

include/boost/iterator/counting_iterator.hpp

@@ -1,7 +1,8 @@
-// Copyright David Abrahams 2003.
-// Distributed under 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)
+// Copyright David Abrahams 2003. 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 COUNTING_ITERATOR_DWA200348_HPP
 # define COUNTING_ITERATOR_DWA200348_HPP
 
@@ -10,7 +11,7 @@
 # include <boost/mpl/bool.hpp>
 # include <boost/mpl/if.hpp>
 # include <boost/mpl/identity.hpp>
-# include <boost/mpl/eval_if.hpp>
+# include <boost/mpl/apply_if.hpp>
 
 namespace boost {
 
@@ -57,11 +58,11 @@ namespace detail
 
 #  if defined(BOOST_HAS_LONG_LONG)
   template <>
-  struct is_numeric< ::boost::long_long_type>
+  struct is_numeric<long long>
     : mpl::true_ {};
   
   template <>
-  struct is_numeric< ::boost::ulong_long_type>
+  struct is_numeric<unsigned long long>
     : mpl::true_ {};
 #  endif
 
@@ -83,7 +84,7 @@ namespace detail
   {
       typedef typename detail::ia_dflt_help<
           CategoryOrTraversal
-        , mpl::eval_if<
+        , mpl::apply_if<
               is_numeric<Incrementable>
             , mpl::identity<random_access_traversal_tag>
             , iterator_traversal<Incrementable>
@@ -92,7 +93,7 @@ namespace detail
       
       typedef typename detail::ia_dflt_help<
           Difference
-        , mpl::eval_if<
+        , mpl::apply_if<
               is_numeric<Incrementable>
             , numeric_difference<Incrementable>
             , iterator_difference<Incrementable>

include/boost/iterator/detail/categories.hpp

@@ -0,0 +1 @@
+#error obsolete

include/boost/iterator/detail/config_def.hpp

@@ -1,9 +1,11 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Distributed under 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)
+// 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.
 
 // no include guard multiple inclusion intended
 
@@ -22,11 +24,7 @@
 # define BOOST_ITERATOR_CONFIG_DEF
 #endif 
 
-// We enable this always now.  Otherwise, the simple case in
-// libs/iterator/test/constant_iterator_arrow.cpp fails to compile
-// because the operator-> return is improperly deduced as a non-const
-// pointer.
-#if 1 || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)           \
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)           \
     || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531))
 
 // Recall that in general, compilers without partial specialization
@@ -40,7 +38,7 @@
 // end up using a proxy for operator[] when we otherwise shouldn't.
 // Using reference constness gives it an extra hint that it can
 // return the value_type from operator[] directly, but is not
-// strictly necessary.  Not sure how best to resolve this one.
+// strictly neccessary.  Not sure how best to resolve this one.
 
 # define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1
 
@@ -48,8 +46,7 @@
 
 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)                                       \
     || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531))                   \
-    || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
-    || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
+    || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER))
 # define BOOST_NO_LVALUE_RETURN_DETECTION
 
 # if 0 // test code
@@ -115,7 +112,7 @@
 # define BOOST_ITERATOR_NO_MPL_AUX_HAS_XXX  // "MPL's has_xxx facility doesn't work"
 #endif 
 
-#if !defined(BOOST_MSVC) && (defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE))
+#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE)
 # define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
 #endif 
 

include/boost/iterator/detail/config_undef.hpp

@@ -1,7 +1,9 @@
 // (C) Copyright Thomas Witt    2002.
-// Distributed under 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)
+// 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.
 
 // no include guard multiple inclusion intended
 

include/boost/iterator/detail/enable_if.hpp

@@ -1,9 +1,11 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Distributed under 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)
+// 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_ENABLE_IF_23022003THW_HPP
 #define BOOST_ENABLE_IF_23022003THW_HPP
 
@@ -72,7 +74,7 @@ namespace boost
       : mpl::identity<Return>
 # endif 
     {
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
         typedef Return type;
 # endif 
     };

include/boost/iterator/detail/facade_iterator_category.hpp

@@ -11,7 +11,7 @@
 # include <boost/mpl/or.hpp>  // used in iterator_tag inheritance logic
 # include <boost/mpl/and.hpp>
 # include <boost/mpl/if.hpp>
-# include <boost/mpl/eval_if.hpp>
+# include <boost/mpl/apply_if.hpp>
 # include <boost/mpl/identity.hpp>
 
 # include <boost/type_traits/is_same.hpp>
@@ -24,7 +24,7 @@
 # include <boost/iterator/detail/config_def.hpp> // try to keep this last
 
 # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-#  include <boost/detail/indirect_traits.hpp>
+#  include <boost/python/detail/indirect_traits.hpp>
 # endif
 
 //
@@ -61,7 +61,7 @@ struct iterator_writability_disabled
 # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY // Adding Thomas' logic?
   : mpl::or_<
         is_const<Reference>
-      , boost::detail::indirect_traits::is_reference_to_const<Reference>
+      , python::detail::is_reference_to_const<Reference>
       , is_const<ValueParam>
     >
 # else 
@@ -86,12 +86,12 @@ struct iterator_writability_disabled
 //
 template <class Traversal, class ValueParam, class Reference>
 struct iterator_facade_default_category
-  : mpl::eval_if<
+  : mpl::apply_if<
         mpl::and_<
             is_reference<Reference>
           , is_convertible<Traversal,forward_traversal_tag>
         >
-      , mpl::eval_if<
+      , mpl::apply_if<
             is_convertible<Traversal,random_access_traversal_tag>
           , mpl::identity<std::random_access_iterator_tag>
           , mpl::if_<
@@ -100,7 +100,7 @@ struct iterator_facade_default_category
               , std::forward_iterator_tag
             >
         >
-      , typename mpl::eval_if<
+      , typename mpl::apply_if<
             mpl::and_<
                 is_convertible<Traversal, single_pass_traversal_tag>
                 
@@ -194,7 +194,7 @@ struct facade_iterator_category_impl
 //
 template <class CategoryOrTraversal, class ValueParam, class Reference>
 struct facade_iterator_category
-  : mpl::eval_if<
+  : mpl::apply_if<
         is_iterator_category<CategoryOrTraversal>
       , mpl::identity<CategoryOrTraversal> // old-style categories are fine as-is
       , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>

include/boost/iterator/detail/minimum_category.hpp

@@ -22,12 +22,8 @@ namespace boost { namespace detail {
 //
 template <bool GreaterEqual, bool LessEqual>
 struct minimum_category_impl
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
 {
-    template <class T1, class T2> struct apply
-    {
-        typedef T2 type;
-    };
     typedef void type;
 }
 # endif 
@@ -77,16 +73,16 @@ template <class T1 = mpl::_1, class T2 = mpl::_2>
 struct minimum_category
 {
     typedef minimum_category_impl< 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1200) // ETI workaround
         is_same<T2,int>::value ||
 # endif 
         ::boost::is_convertible<T1,T2>::value
       , ::boost::is_convertible<T2,T1>::value
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1200) // ETI workaround
         || is_same<T1,int>::value
 # endif 
     > outer;
-
+      
     typedef typename outer::template apply<T1,T2> inner;
     typedef typename inner::type type;
       
@@ -99,18 +95,16 @@ struct minimum_category<mpl::_1,mpl::_2>
     template <class T1, class T2>
     struct apply : minimum_category<T1,T2>
     {};
-
-    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,minimum_category,(mpl::_1,mpl::_2))
 };
-
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
+    
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1200) // ETI workaround
 template <>
 struct minimum_category<int,int>
 {
     typedef int type;
 };
 # endif
-    
+
 }} // namespace boost::detail
 
 #endif // MINIMUM_CATEGORY_DWA20031119_HPP

include/boost/iterator/filter_iterator.hpp

@@ -1,9 +1,11 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Distributed under 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)
+// 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_FILTER_ITERATOR_23022003THW_HPP
 #define BOOST_FILTER_ITERATOR_23022003THW_HPP
 
@@ -31,9 +33,9 @@ namespace boost
           , typename mpl::if_<
                 is_convertible<
                     typename iterator_traversal<Iterator>::type
-                  , random_access_traversal_tag
+                  , bidirectional_traversal_tag
                 >
-              , bidirectional_traversal_tag
+              , forward_traversal_tag
               , use_default
             >::type
         > type;
@@ -122,7 +124,7 @@ namespace boost
         , Iterator
       >::type x
     , Iterator end = Iterator()
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
     , Predicate* = 0
 #endif 
   )

include/boost/iterator/indirect_iterator.hpp

@@ -1,9 +1,11 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Distributed under 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)
+// 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_INDIRECT_ITERATOR_23022003THW_HPP
 #define BOOST_INDIRECT_ITERATOR_23022003THW_HPP
 
@@ -14,18 +16,18 @@
 #include <boost/indirect_reference.hpp>
 #include <boost/detail/iterator.hpp>
 
-#include <boost/detail/indirect_traits.hpp>
+#include <boost/python/detail/indirect_traits.hpp>
 
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/add_reference.hpp>
 
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/identity.hpp>
-#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/apply_if.hpp>
 #include <boost/mpl/not.hpp>
-#include <boost/mpl/has_xxx.hpp>
+#include <boost/mpl/aux_/has_xxx.hpp>
 
-#ifdef BOOST_MPL_CFG_NO_HAS_XXX
+#ifdef BOOST_MPL_NO_AUX_HAS_XXX
 # include <boost/shared_ptr.hpp>
 # include <boost/scoped_ptr.hpp>
 # include <boost/mpl/bool.hpp>
@@ -55,7 +57,7 @@ namespace boost
           , Category
           , typename ia_dflt_help<
                 Reference
-              , mpl::eval_if<
+              , mpl::apply_if<
                     is_same<Value,use_default>
                   , indirect_reference<dereferenceable>
                   , add_reference<Value>

include/boost/iterator/interoperable.hpp

@@ -1,9 +1,11 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Distributed under 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)
+// 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_INTEROPERABLE_23022003THW_HPP
 # define BOOST_INTEROPERABLE_23022003THW_HPP
 

include/boost/iterator/iterator_adaptor.hpp

@@ -1,9 +1,11 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Distributed under 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)
+// 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_ITERATOR_ADAPTOR_23022003THW_HPP
 #define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
 
@@ -100,22 +102,7 @@ namespace boost
   // false positives for user/library defined iterator types. See comments
   // on operator implementation for consequences.
   //
-#  if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-  
-  template<typename From, typename To>
-  struct enable_if_convertible
-  {
-     typedef typename mpl::if_<
-         mpl::or_<
-             is_same<From,To>
-           , is_convertible<From, To>
-         >
-      , detail::enable_type
-      , int&
-     >::type type;
-  };
-  
-#  elif defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
+#  if defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
   
   template <class From, class To>
   struct enable_if_convertible
@@ -159,7 +146,7 @@ namespace boost
     // DefaultNullaryFn, otherwise return T.
     template <class T, class DefaultNullaryFn>
     struct ia_dflt_help
-      : mpl::eval_if<
+      : mpl::apply_if<
             is_same<T, use_default>
           , DefaultNullaryFn
           , mpl::identity<T>
@@ -185,7 +172,7 @@ namespace boost
 # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
           , typename detail::ia_dflt_help<
                 Value
-              , mpl::eval_if<
+              , mpl::apply_if<
                     is_same<Reference,use_default>
                   , iterator_value<Base>
                   , remove_reference<Reference>
@@ -204,7 +191,7 @@ namespace boost
 
           , typename detail::ia_dflt_help<
                 Reference
-              , mpl::eval_if<
+              , mpl::apply_if<
                     is_same<Value,use_default>
                   , iterator_reference<Base>
                   , add_reference<Value>
@@ -217,13 +204,7 @@ namespace boost
         >
         type;
     };
-  
-    // workaround for aC++ CR JAGaf33512
-    template <class Tr1, class Tr2>
-    inline void iterator_adaptor_assert_traversal ()
-    {
-      BOOST_STATIC_ASSERT((is_convertible<Tr1, Tr2>::value));
-    }
+    template <class T> int static_assert_convertible_to(T);
   }
   
   //
@@ -278,8 +259,6 @@ namespace boost
       {
       }
 
-      typedef Base base_type;
-
       Base const& base() const
         { return m_iterator; }
 
@@ -323,7 +302,8 @@ namespace boost
       >::type my_traversal;
 
 # define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \
-      detail::iterator_adaptor_assert_traversal<my_traversal, cat>();
+      typedef int assertion[sizeof(detail::static_assert_convertible_to<cat>(my_traversal()))];
+//      BOOST_STATIC_ASSERT((is_convertible<my_traversal,cat>::value));
 
       void advance(typename super_t::difference_type n)
       {

include/boost/iterator/iterator_archetypes.hpp

@@ -1,7 +1,8 @@
-// (C) Copyright Jeremy Siek 2002.
-// Distributed under 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)
+// (C) Copyright Jeremy Siek 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.
 
 #ifndef BOOST_ITERATOR_ARCHETYPES_HPP
 #define BOOST_ITERATOR_ARCHETYPES_HPP
@@ -25,7 +26,7 @@
 #include <boost/mpl/int.hpp>
 #include <boost/mpl/equal_to.hpp>
 #include <boost/mpl/if.hpp>
-#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/apply_if.hpp>
 #include <boost/mpl/and.hpp>
 #include <boost/mpl/identity.hpp>
 
@@ -120,9 +121,9 @@ namespace detail
   template <class Value, class AccessCategory, class TraversalCategory>
   struct operator_brackets
     : mpl::aux::msvc_eti_base<
-          typename mpl::eval_if<
+          typename mpl::apply_if<
               is_convertible<TraversalCategory, random_access_traversal_tag>
-            , mpl::eval_if<
+            , mpl::apply_if<
                   iterator_archetypes::has_access<
                       AccessCategory
                     , iterator_archetypes::writable_iterator_t
@@ -240,7 +241,8 @@ namespace detail
   {
       template<class Derived, class Value>
       struct archetype
-        : public traversal_archetype_<Derived, Value, bidirectional_traversal_tag> 
+        : public partially_ordered<traversal_archetype_<Derived, Value, random_access_traversal_tag> >,
+          public traversal_archetype_<Derived, Value, bidirectional_traversal_tag> 
       {
           Derived& operator+=(std::ptrdiff_t) { return static_object<Derived>::get(); }
           Derived& operator-=(std::ptrdiff_t) { return static_object<Derived>::get(); }
@@ -271,21 +273,6 @@ namespace detail
                  traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
       { return true; }
 
-  template <class Derived, class Value>
-  bool operator>(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-                 traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
-      { return true; }
-
-  template <class Derived, class Value>
-  bool operator<=(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-                 traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
-      { return true; }
-
-  template <class Derived, class Value>
-  bool operator>=(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-                 traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
-      { return true; }
-
   struct bogus_type;
 
   template <class Value>
@@ -431,7 +418,7 @@ namespace detail
       
       typedef typename detail::facade_iterator_category<
           TraversalCategory
-        , typename mpl::eval_if<
+        , typename mpl::apply_if<
               iterator_archetypes::has_access<
                   AccessCategory, iterator_archetypes::writable_iterator_t
               >

include/boost/iterator/iterator_categories.hpp

@@ -1,7 +1,8 @@
-// (C) Copyright Jeremy Siek 2002.
-// Distributed under 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)
+// (C) Copyright Jeremy Siek 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.
 
 #ifndef BOOST_ITERATOR_CATEGORIES_HPP
 # define BOOST_ITERATOR_CATEGORIES_HPP
@@ -12,7 +13,7 @@
 
 # include <boost/detail/workaround.hpp>
 
-# include <boost/mpl/eval_if.hpp>
+# include <boost/mpl/apply_if.hpp>
 # include <boost/mpl/identity.hpp>
 # include <boost/mpl/placeholders.hpp>
 # include <boost/mpl/aux_/lambda_support.hpp>
@@ -74,19 +75,19 @@ namespace detail
   //
   template <class Cat>
   struct old_category_to_traversal
-    : mpl::eval_if<
+    : mpl::apply_if<
           is_convertible<Cat,std::random_access_iterator_tag>
         , mpl::identity<random_access_traversal_tag>
-        , mpl::eval_if<
+        , mpl::apply_if<
               is_convertible<Cat,std::bidirectional_iterator_tag>
             , mpl::identity<bidirectional_traversal_tag>
-            , mpl::eval_if<
+            , mpl::apply_if<
                   is_convertible<Cat,std::forward_iterator_tag>
                 , mpl::identity<forward_traversal_tag>
-                , mpl::eval_if<
+                , mpl::apply_if<
                       is_convertible<Cat,std::input_iterator_tag>
                     , mpl::identity<single_pass_traversal_tag>
-                    , mpl::eval_if<
+                    , mpl::apply_if<
                           is_convertible<Cat,std::output_iterator_tag>
                         , mpl::identity<incrementable_traversal_tag>
                         , void
@@ -97,7 +98,7 @@ namespace detail
       >
   {};
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
   template <>
   struct old_category_to_traversal<int>
   {
@@ -107,19 +108,19 @@ namespace detail
 
   template <class Traversal>
   struct pure_traversal_tag
-    : mpl::eval_if<
+    : mpl::apply_if<
           is_convertible<Traversal,random_access_traversal_tag>
         , mpl::identity<random_access_traversal_tag>
-        , mpl::eval_if<
+        , mpl::apply_if<
               is_convertible<Traversal,bidirectional_traversal_tag>
             , mpl::identity<bidirectional_traversal_tag>
-            , mpl::eval_if<
+            , mpl::apply_if<
                   is_convertible<Traversal,forward_traversal_tag>
                 , mpl::identity<forward_traversal_tag>
-                , mpl::eval_if<
+                , mpl::apply_if<
                       is_convertible<Traversal,single_pass_traversal_tag>
                     , mpl::identity<single_pass_traversal_tag>
-                    , mpl::eval_if<
+                    , mpl::apply_if<
                           is_convertible<Traversal,incrementable_traversal_tag>
                         , mpl::identity<incrementable_traversal_tag>
                         , void
@@ -131,7 +132,7 @@ namespace detail
   {
   };
   
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
   template <>
   struct pure_traversal_tag<int>
   {
@@ -147,7 +148,7 @@ namespace detail
 //
 template <class Cat>
 struct iterator_category_to_traversal
-  : mpl::eval_if< // if already convertible to a traversal tag, we're done.
+  : mpl::apply_if< // if already convertible to a traversal tag, we're done.
         is_convertible<Cat,incrementable_traversal_tag>
       , mpl::identity<Cat>
       , detail::old_category_to_traversal<Cat>
@@ -162,7 +163,7 @@ struct iterator_traversal
     >
 {};
 
-# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
+# ifdef BOOST_MPL_NO_FULL_LAMBDA_SUPPORT
 // Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work
 // out well.  Instantiating the nested apply template also
 // requires instantiating iterator_traits on the

include/boost/iterator/iterator_concepts.hpp

@@ -1,7 +1,8 @@
-// (C) Copyright Jeremy Siek 2002.
-// Distributed under 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)
+// (C) Copyright Jeremy Siek 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.
 
 #ifndef BOOST_ITERATOR_CONCEPTS_HPP
 #define BOOST_ITERATOR_CONCEPTS_HPP
@@ -31,7 +32,6 @@
 
 // Use boost/limits to work around missing limits headers on some compilers
 #include <boost/limits.hpp>
-#include <boost/config.hpp>
 
 #include <algorithm>
 

include/boost/iterator/iterator_facade.hpp

@@ -1,12 +1,16 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Distributed under 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)
+// 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_ITERATOR_FACADE_23022003THW_HPP
 #define BOOST_ITERATOR_FACADE_23022003THW_HPP
 
+#include <boost/static_assert.hpp>
+
 #include <boost/iterator.hpp>
 #include <boost/iterator/interoperable.hpp>
 #include <boost/iterator/iterator_traits.hpp>
@@ -14,9 +18,6 @@
 #include <boost/iterator/detail/facade_iterator_category.hpp>
 #include <boost/iterator/detail/enable_if.hpp>
 
-#include <boost/implicit_cast.hpp>
-#include <boost/static_assert.hpp>
-
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/add_pointer.hpp>
@@ -25,7 +26,7 @@
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/type_traits/is_pod.hpp>
 
-#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/apply_if.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/mpl/or.hpp>
 #include <boost/mpl/and.hpp>
@@ -55,7 +56,7 @@ namespace boost
             typedef bool type;
         };
     };
-
+    
     //
     // enable if for use in operator implementation.
     //
@@ -65,18 +66,6 @@ namespace boost
       , class Return
     >
     struct enable_if_interoperable
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-    {
-        typedef typename mpl::if_<
-            mpl::or_<
-                is_convertible<Facade1, Facade2>
-              , is_convertible<Facade2, Facade1>
-            >
-          , Return
-          , int[3]
-        >::type type;
-    };        
-#else
       : ::boost::iterators::enable_if<
            mpl::or_<
                is_convertible<Facade1, Facade2>
@@ -84,8 +73,8 @@ namespace boost
            >
          , Return
         >
-    {};
-#endif 
+    {
+    };
 
     //
     // Generates associated types for an iterator_facade with the
@@ -105,9 +94,9 @@ namespace boost
         
         typedef typename remove_const<ValueParam>::type value_type;
         
-        typedef typename mpl::eval_if<
+        typedef typename mpl::apply_if<
             detail::iterator_writability_disabled<ValueParam,Reference>
-          , add_pointer<const value_type>
+          , add_pointer<typename add_const<value_type>::type>
           , add_pointer<value_type>
         >::type pointer;
       
@@ -202,13 +191,6 @@ namespace boost
             *this->stored_iterator = x;
             return x;
         }
-
-        // Provides X(r++)
-        operator Iterator const&() const
-        {
-            return stored_iterator;
-        }
-        
      private:
         mutable value_type stored_value;
         Iterator stored_iterator;
@@ -268,10 +250,10 @@ namespace boost
     // *r also returns a proxy.
     template <class Iterator, class Value, class Reference, class CategoryOrTraversal>
     struct postfix_increment_result
-      : mpl::eval_if<
+      : mpl::apply_if<
             mpl::and_<
-                // A proxy is only needed for readable iterators
-                is_convertible<Reference,Value const&>
+            // A proxy is only needed for readable iterators
+            is_convertible<Reference,Value>
                 
                 // No multipass iterator can have values that disappear
                 // before positions can be re-visited
@@ -323,11 +305,11 @@ namespace boost
 
         static type make(Reference x)
         {
-            return implicit_cast<type>(&x);
+            return type(&x);
         }
     };
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
     // Deal with ETI
     template<>
     struct operator_arrow_result<int, int, int>
@@ -410,14 +392,14 @@ namespace boost
           :
 # ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
           iterator_difference<I1>
-# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# elif BOOST_WORKAROUND(BOOST_MSVC, == 1200)
           mpl::if_<
               is_convertible<I2,I1>
             , typename I1::difference_type
             , typename I2::difference_type
           >
 # else 
-          mpl::eval_if<
+          mpl::apply_if<
               is_convertible<I2,I1>
             , iterator_difference<I1>
             , iterator_difference<I2>
@@ -666,7 +648,7 @@ namespace boost
           return this->derived();
       }
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
       typename detail::postfix_increment_result<Derived,Value,Reference,CategoryOrTraversal>::type
       operator++(int)
       {
@@ -708,7 +690,7 @@ namespace boost
           return result -= x;
       }
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
       // There appears to be a bug which trashes the data of classes
       // derived from iterator_facade when they are assigned unless we
       // define this assignment operator.  This bug is only revealed
@@ -721,7 +703,7 @@ namespace boost
 # endif
   };
 
-# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if !BOOST_WORKAROUND(BOOST_MSVC, == 1200)
   template <class I, class V, class TC, class R, class D>
   typename detail::postfix_increment_result<I,V,R,TC>::type
   operator++(
@@ -820,8 +802,8 @@ namespace boost
           is_interoperable< Derived1, Derived2 >::value                         \
       ));                                                                       \
       return_prefix iterator_core_access::base_op(                              \
-          *static_cast<Derived1 const*>(&lhs)                                   \
-        , *static_cast<Derived2 const*>(&rhs)                                   \
+          static_cast<Derived1 const&>(lhs)                                     \
+        , static_cast<Derived2 const&>(rhs)                                     \
         , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1)                         \
       );                                                                        \
   }

include/boost/iterator/iterator_traits.hpp

@@ -1,7 +1,8 @@
-// Copyright David Abrahams 2003.
-// Distributed under 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)
+// Copyright David Abrahams 2003. 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 ITERATOR_TRAITS_DWA200347_HPP
 # define ITERATOR_TRAITS_DWA200347_HPP
 
@@ -55,7 +56,7 @@ struct BOOST_ITERATOR_CATEGORY
     typedef typename detail::iterator_traits<Iterator>::iterator_category type;
 };
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
 template <>
 struct iterator_value<int>
 {

include/boost/iterator/new_iterator_tests.hpp

@@ -1,17 +1,6 @@
 #ifndef BOOST_NEW_ITERATOR_TESTS_HPP
 # define BOOST_NEW_ITERATOR_TESTS_HPP
 
-//
-// Copyright (c) David Abrahams 2001.
-// Copyright (c) Jeremy Siek 2001-2003.
-// Copyright (c) Thomas Witt 2002.
-//
-// 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)
-//
-
 // This is meant to be the beginnings of a comprehensive, generic
 // test suite for STL concepts such as iterators and containers.
 //
@@ -49,7 +38,7 @@ namespace boost {
 template <class Iterator, class T>
 void readable_iterator_traversal_test(Iterator i1, T v, mpl::true_)
 {
-    T v2(*i1++);
+    T v2 = *i1++;
     assert(v == v2);
 }
 
@@ -62,8 +51,6 @@ void writable_iterator_traversal_test(Iterator i1, T v, mpl::true_)
 {
     ++i1;  // we just wrote into that position
     *i1++ = v;
-    Iterator x(i1++);
-    (void)x;
 }
 
 template <class Iterator, class T>

include/boost/iterator/permutation_iterator.hpp

@@ -1,9 +1,10 @@
 // (C) Copyright Toon Knapen    2001.
 // (C) Copyright David Abrahams 2003.
 // (C) Copyright Roland Richter 2003.
-// Distributed under 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)
+// 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_PERMUTATION_ITERATOR_HPP
 #define BOOST_PERMUTATION_ITERATOR_HPP

include/boost/iterator/reverse_iterator.hpp

@@ -1,9 +1,11 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Distributed under 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)
+// 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_REVERSE_ITERATOR_23022003THW_HPP
 #define BOOST_REVERSE_ITERATOR_23022003THW_HPP
 

include/boost/iterator/transform_iterator.hpp

@@ -1,9 +1,11 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Distributed under 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)
+// 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_TRANSFORM_ITERATOR_23022003THW_HPP
 #define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
 
@@ -122,7 +124,7 @@ namespace boost
     transform_iterator(
          transform_iterator<OtherUnaryFunction, OtherIterator, OtherReference, OtherValue> const& t
        , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
-#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
        , typename enable_if_convertible<OtherUnaryFunction, UnaryFunction>::type* = 0
 #endif 
     )
@@ -156,16 +158,9 @@ namespace boost
   // function pointer in the iterator be 0, leading to a runtime
   // crash.
   template <class UnaryFunction, class Iterator>
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-  typename mpl::if_<
-#else 
   typename iterators::enable_if<
-#endif 
       is_class<UnaryFunction>   // We should probably find a cheaper test than is_class<>
     , transform_iterator<UnaryFunction, Iterator>
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-    , int[3]
-#endif 
   >::type
   make_transform_iterator(Iterator it)
   {

include/boost/iterator/zip_iterator.hpp

@@ -19,7 +19,6 @@
 // Borland 5.5.1 (broken due to lack of support from Boost.Tuples)
 
 #ifndef BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_
-# define BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_
 
 #include <stddef.h>
 #include <boost/iterator.hpp>
@@ -36,7 +35,7 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/mpl/and.hpp>
 #include <boost/mpl/apply.hpp>
-#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/apply_if.hpp>
 #include <boost/mpl/lambda.hpp>
 #include <boost/mpl/placeholders.hpp>
 #include <boost/mpl/aux_/lambda_support.hpp>
@@ -141,7 +140,7 @@ namespace boost {
 
       template<typename Tuple, class UnaryMetaFun>
       struct tuple_meta_transform
-        : mpl::eval_if<
+        : mpl::apply_if<
               boost::is_same<Tuple, tuples::null_type>
             , mpl::identity<tuples::null_type>
             , tuple_meta_transform_impl<Tuple, UnaryMetaFun>
@@ -180,12 +179,12 @@ namespace boost {
         , typename StartType
       >
       struct tuple_meta_accumulate
-        : mpl::eval_if<
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+        : mpl::apply_if<
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
               mpl::or_<
 #endif 
                   boost::is_same<Tuple, tuples::null_type>
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
                 , boost::is_same<Tuple,int>
               >
 #endif 
@@ -338,7 +337,7 @@ namespace boost {
         typedef typename iterator_traits<Iterator>::reference type;
     };
 
-#ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
+#ifdef BOOST_MPL_NO_FULL_LAMBDA_SUPPORT
     // Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work
     // out well.  Instantiating the nested apply template also
     // requires instantiating iterator_traits on the
@@ -382,7 +381,7 @@ namespace boost {
       >::type type;
     };
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1200) // ETI workaround
       template <>
       struct minimum_traversal_category_in_iterator_tuple<int>
       {
@@ -401,7 +400,7 @@ namespace boost {
       {
       };
     
-# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
+# ifdef BOOST_MPL_NO_FULL_LAMBDA_SUPPORT
   // Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work
   // out well.  In this case I think it's an MPL bug
       template<>

include/boost/iterator_adaptors.hpp

@@ -1,10 +1,13 @@
-// Copyright David Abrahams 2004. Distributed under 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 ITERATOR_ADAPTORS_DWA2004725_HPP
-# define ITERATOR_ADAPTORS_DWA2004725_HPP
+// 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_ITERATOR_ADAPTOR_13062003HK_HPP
+#define BOOST_ITERATOR_ADAPTOR_13062003HK_HPP
 
 #define BOOST_ITERATOR_ADAPTORS_VERSION 0x0200
 #include <boost/iterator/iterator_adaptor.hpp>
 
-#endif // ITERATOR_ADAPTORS_DWA2004725_HPP
+#endif // BOOST_ITERATOR_ADAPTOR_13062003HK_HPP

include/boost/pending/detail/int_iterator.hpp

@@ -1,7 +1,8 @@
-//  (C) Copyright Jeremy Siek 1999.
-//  Distributed under 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)
+//  (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/pending/integer_range.hpp

@@ -1,7 +1,8 @@
-// (C) Copyright David Abrahams and Jeremy Siek 2000-2001.
-// Distributed under 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)
+// (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

include/boost/pending/iterator_adaptors.hpp

@@ -1,6 +1,7 @@
-// Copyright David Abrahams 2003.
-// Distributed under 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)
+// Copyright David Abrahams 2003. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
 
 #include <boost/iterator_adaptors.hpp>

include/boost/pending/iterator_tests.hpp

@@ -1,7 +1,8 @@
-// Copyright David Abrahams and Jeremy Siek 2003.
-// Distributed under 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)
+// Copyright David Abrahams and Jeremy Siek 2003. 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_ITERATOR_TESTS_HPP
 # define BOOST_ITERATOR_TESTS_HPP
 

include/boost/pointee.hpp

@@ -1,24 +1,18 @@
-#ifndef POINTEE_DWA200415_HPP
-# define POINTEE_DWA200415_HPP
-
-//
 // 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)
-//
-// typename pointee<P>::type provides the pointee type of P.
-//
-// For example, it is T for T* and X for shared_ptr<X>.
-//
-// http://www.boost.org/libs/iterator/doc/pointee.html
-//
+#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/eval_if.hpp>
+# include <boost/mpl/apply_if.hpp>
 
 namespace boost { 
 
@@ -61,7 +55,7 @@ namespace detail
 
 template <class P>
 struct pointee
-  : mpl::eval_if<
+  : mpl::apply_if<
         detail::is_incrementable<P>
       , detail::iterator_pointee<P>
       , detail::smart_ptr_pointee<P>