Merge pull request #149 from tklab-tud/sradomski

remerge

12 files changed, 2617 insertions, 2617 deletions

diff --git a/contrib/src/boost/iterator/detail/config_def.hpp b/contrib/src/boost/iterator/detail/config_def.hpp
index 4ec35c7..117e75a 100644
--- a/contrib/src/boost/iterator/detail/config_def.hpp
+++ b/contrib/src/boost/iterator/detail/config_def.hpp
@@ -1,128 +1,128 @@
-// (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)

-

-// no include guard multiple inclusion intended

-

-//

-// This is a temporary workaround until the bulk of this is

-// available in boost config.

-// 23/02/03 thw

-//

-

-#include <boost/config.hpp> // for prior

-#include <boost/detail/workaround.hpp>

-

-#ifdef BOOST_ITERATOR_CONFIG_DEF

-# error you have nested config_def #inclusion.

-#else 

-# 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)           \

-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531))

-

-// Recall that in general, compilers without partial specialization

-// can't strip constness.  Consider counting_iterator, which normally

-// passes a const Value to iterator_facade.  As a result, any code

-// which makes a std::vector of the iterator's value_type will fail

-// when its allocator declares functions overloaded on reference and

-// const_reference (the same type).

-//

-// Furthermore, Borland 5.5.1 drops constness in enough ways that we

-// 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.

-

-# define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1

-

-#endif

-

-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0))                      \

-    || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \

-    || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))                \

-    || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))

-    

-# define BOOST_NO_LVALUE_RETURN_DETECTION

-

-# if 0 // test code

-  struct v  {};

-

-  typedef  char (&no)[3];

-

-  template <class T>

-  no foo(T const&, ...);

-

-  template <class T>

-  char foo(T&, int);

-

-

-  struct value_iterator

-  {

-      v operator*() const;

-  };

-

-  template <class T>

-  struct lvalue_deref_helper

-  {

-      static T& x;

-      enum { value = (sizeof(foo(*x,0)) == 1) };

-  };

-

-  int z2[(lvalue_deref_helper<v*>::value == 1) ? 1 : -1];

-  int z[(lvalue_deref_helper<value_iterator>::value) == 1 ? -1 : 1 ];

-# endif 

-

-#endif

-

-#if BOOST_WORKAROUND(__MWERKS__, <=0x2407)

-#  define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"

-#endif

-

-#if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \

-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))

-#  define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:

-

-#  if 0 // test code

-    #include <boost/type_traits/is_convertible.hpp>

-    template <class T>

-    struct foo

-    {

-        foo(T);

-

-        template <class U>

-        foo(foo<U> const& other) : p(other.p) { }

-

-        T p;

-    };

-

-    bool x = boost::is_convertible<foo<int const*>, foo<int*> >::value;

-#  endif

-

-#endif

-

-

-#if !defined(BOOST_MSVC) && (defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE))

-# define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY

-#endif 

-

-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

-

-// GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion

-// operators in convertibility checks, causing premature errors.

-//

-// Borland's problems are harder to diagnose due to lack of an

-// instantiation stack backtrace.  They may be due in part to the fact

-// that it drops cv-qualification willy-nilly in templates.

-#  define BOOST_NO_ONE_WAY_ITERATOR_INTEROP

-# endif 

-

-// no include guard; multiple inclusion intended

+// (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)
+
+// no include guard multiple inclusion intended
+
+//
+// This is a temporary workaround until the bulk of this is
+// available in boost config.
+// 23/02/03 thw
+//
+
+#include <boost/config.hpp> // for prior
+#include <boost/detail/workaround.hpp>
+
+#ifdef BOOST_ITERATOR_CONFIG_DEF
+# error you have nested config_def #inclusion.
+#else 
+# 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)           \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531))
+
+// Recall that in general, compilers without partial specialization
+// can't strip constness.  Consider counting_iterator, which normally
+// passes a const Value to iterator_facade.  As a result, any code
+// which makes a std::vector of the iterator's value_type will fail
+// when its allocator declares functions overloaded on reference and
+// const_reference (the same type).
+//
+// Furthermore, Borland 5.5.1 drops constness in enough ways that we
+// 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.
+
+# define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1
+
+#endif
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0))                      \
+    || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
+    || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))                \
+    || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+    
+# define BOOST_NO_LVALUE_RETURN_DETECTION
+
+# if 0 // test code
+  struct v  {};
+
+  typedef  char (&no)[3];
+
+  template <class T>
+  no foo(T const&, ...);
+
+  template <class T>
+  char foo(T&, int);
+
+
+  struct value_iterator
+  {
+      v operator*() const;
+  };
+
+  template <class T>
+  struct lvalue_deref_helper
+  {
+      static T& x;
+      enum { value = (sizeof(foo(*x,0)) == 1) };
+  };
+
+  int z2[(lvalue_deref_helper<v*>::value == 1) ? 1 : -1];
+  int z[(lvalue_deref_helper<value_iterator>::value) == 1 ? -1 : 1 ];
+# endif 
+
+#endif
+
+#if BOOST_WORKAROUND(__MWERKS__, <=0x2407)
+#  define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"
+#endif
+
+#if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+#  define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:
+
+#  if 0 // test code
+    #include <boost/type_traits/is_convertible.hpp>
+    template <class T>
+    struct foo
+    {
+        foo(T);
+
+        template <class U>
+        foo(foo<U> const& other) : p(other.p) { }
+
+        T p;
+    };
+
+    bool x = boost::is_convertible<foo<int const*>, foo<int*> >::value;
+#  endif
+
+#endif
+
+
+#if !defined(BOOST_MSVC) && (defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE))
+# define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+#endif 
+
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+// GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion
+// operators in convertibility checks, causing premature errors.
+//
+// Borland's problems are harder to diagnose due to lack of an
+// instantiation stack backtrace.  They may be due in part to the fact
+// that it drops cv-qualification willy-nilly in templates.
+#  define BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+# endif 
+
+// no include guard; multiple inclusion intended
diff --git a/contrib/src/boost/iterator/detail/config_undef.hpp b/contrib/src/boost/iterator/detail/config_undef.hpp
index 070efbb..bf1b8d7 100644
--- a/contrib/src/boost/iterator/detail/config_undef.hpp
+++ b/contrib/src/boost/iterator/detail/config_undef.hpp
@@ -1,24 +1,24 @@
-// (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)

-

-// no include guard multiple inclusion intended

-

-//

-// This is a temporary workaround until the bulk of this is

-// available in boost config.

-// 23/02/03 thw

-//

-

-#undef BOOST_NO_IS_CONVERTIBLE

-#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE

-#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY

-#undef BOOST_NO_LVALUE_RETURN_DETECTION

-#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP

-

-#ifdef BOOST_ITERATOR_CONFIG_DEF

-# undef BOOST_ITERATOR_CONFIG_DEF

-#else

-# error missing or nested #include config_def

-#endif 

+// (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)
+
+// no include guard multiple inclusion intended
+
+//
+// This is a temporary workaround until the bulk of this is
+// available in boost config.
+// 23/02/03 thw
+//
+
+#undef BOOST_NO_IS_CONVERTIBLE
+#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
+#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+#undef BOOST_NO_LVALUE_RETURN_DETECTION
+#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+
+#ifdef BOOST_ITERATOR_CONFIG_DEF
+# undef BOOST_ITERATOR_CONFIG_DEF
+#else
+# error missing or nested #include config_def
+#endif 
diff --git a/contrib/src/boost/iterator/detail/enable_if.hpp b/contrib/src/boost/iterator/detail/enable_if.hpp
index c0da4b4..071f5fe 100644
--- a/contrib/src/boost/iterator/detail/enable_if.hpp
+++ b/contrib/src/boost/iterator/detail/enable_if.hpp
@@ -1,83 +1,83 @@
-// (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)

-#ifndef BOOST_ENABLE_IF_23022003THW_HPP

-#define BOOST_ENABLE_IF_23022003THW_HPP

-

-#include <boost/detail/workaround.hpp>

-#include <boost/mpl/identity.hpp>

-

-#include <boost/iterator/detail/config_def.hpp>

-

-//

-// Boost iterators uses its own enable_if cause we need

-// special semantics for deficient compilers.

-// 23/02/03 thw

-//

-

-namespace boost

-{

-

-  namespace iterators

-  {

-    //

-    // Base machinery for all kinds of enable if

-    //

-    template<bool>

-    struct enabled

-    {

-      template<typename T>

-      struct base

-      {

-        typedef T type;

-      };

-    };

-

-    //

-    // For compilers that don't support "Substitution Failure Is Not An Error"

-    // enable_if falls back to always enabled. See comments

-    // on operator implementation for consequences.

-    //

-    template<>

-    struct enabled<false>

-    {

-      template<typename T>

-      struct base

-      {

-#ifdef BOOST_NO_SFINAE

-

-        typedef T type;

-

-        // This way to do it would give a nice error message containing

-        // invalid overload, but has the big disadvantage that

-        // there is no reference to user code in the error message.

-        //

-        // struct invalid_overload;

-        // typedef invalid_overload type;

-        //

-#endif

-      };

-    };

-

-

-    template <class Cond,

-              class Return>

-    struct enable_if

-# if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE)

-      : enabled<(Cond::value)>::template base<Return>

-# else

-      : mpl::identity<Return>

-# endif

-    {

-    };

-

-  } // namespace iterators

-

-} // namespace boost

-

-#include <boost/iterator/detail/config_undef.hpp>

-

-#endif // BOOST_ENABLE_IF_23022003THW_HPP

+// (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)
+#ifndef BOOST_ENABLE_IF_23022003THW_HPP
+#define BOOST_ENABLE_IF_23022003THW_HPP
+
+#include <boost/detail/workaround.hpp>
+#include <boost/mpl/identity.hpp>
+
+#include <boost/iterator/detail/config_def.hpp>
+
+//
+// Boost iterators uses its own enable_if cause we need
+// special semantics for deficient compilers.
+// 23/02/03 thw
+//
+
+namespace boost
+{
+
+  namespace iterators
+  {
+    //
+    // Base machinery for all kinds of enable if
+    //
+    template<bool>
+    struct enabled
+    {
+      template<typename T>
+      struct base
+      {
+        typedef T type;
+      };
+    };
+
+    //
+    // For compilers that don't support "Substitution Failure Is Not An Error"
+    // enable_if falls back to always enabled. See comments
+    // on operator implementation for consequences.
+    //
+    template<>
+    struct enabled<false>
+    {
+      template<typename T>
+      struct base
+      {
+#ifdef BOOST_NO_SFINAE
+
+        typedef T type;
+
+        // This way to do it would give a nice error message containing
+        // invalid overload, but has the big disadvantage that
+        // there is no reference to user code in the error message.
+        //
+        // struct invalid_overload;
+        // typedef invalid_overload type;
+        //
+#endif
+      };
+    };
+
+
+    template <class Cond,
+              class Return>
+    struct enable_if
+# if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE)
+      : enabled<(Cond::value)>::template base<Return>
+# else
+      : mpl::identity<Return>
+# endif
+    {
+    };
+
+  } // namespace iterators
+
+} // namespace boost
+
+#include <boost/iterator/detail/config_undef.hpp>
+
+#endif // BOOST_ENABLE_IF_23022003THW_HPP
diff --git a/contrib/src/boost/iterator/detail/facade_iterator_category.hpp b/contrib/src/boost/iterator/detail/facade_iterator_category.hpp
index 73f5ff9..67fdf44 100644
--- a/contrib/src/boost/iterator/detail/facade_iterator_category.hpp
+++ b/contrib/src/boost/iterator/detail/facade_iterator_category.hpp
@@ -1,193 +1,193 @@
-// Copyright David Abrahams 2003. Use, modification and distribution is

-// subject to the Boost Software License, Version 1.0. (See accompanying

-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-#ifndef FACADE_ITERATOR_CATEGORY_DWA20031118_HPP

-# define FACADE_ITERATOR_CATEGORY_DWA20031118_HPP

-

-# include <boost/iterator/iterator_categories.hpp>

-

-# 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/identity.hpp>

-# include <boost/mpl/assert.hpp>

-

-# include <boost/type_traits/is_same.hpp>

-# include <boost/type_traits/is_const.hpp>

-# include <boost/type_traits/is_reference.hpp>

-# include <boost/type_traits/is_convertible.hpp>

-

-# include <boost/type_traits/is_same.hpp>

-

-# 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>

-# endif

-

-//

-// iterator_category deduction for iterator_facade

-//

-

-namespace boost {

-namespace iterators {

-

-// forward declaration

-struct use_default;

-

-namespace detail {

-

-struct input_output_iterator_tag

-  : std::input_iterator_tag

-{

-    // Using inheritance for only input_iterator_tag helps to avoid

-    // ambiguities when a stdlib implementation dispatches on a

-    // function which is overloaded on both input_iterator_tag and

-    // output_iterator_tag, as STLPort does, in its __valid_range

-    // function.  I claim it's better to avoid the ambiguity in these

-    // cases.

-    operator std::output_iterator_tag() const

-    {

-        return std::output_iterator_tag();

-    }

-};

-

-//

-// True iff the user has explicitly disabled writability of this

-// iterator.  Pass the iterator_facade's Value parameter and its

-// nested ::reference type.

-//

-template <class ValueParam, class Reference>

-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>

-      , is_const<ValueParam>

-    >

-# else

-  : is_const<ValueParam>

-# endif

-{};

-

-

-//

-// Convert an iterator_facade's traversal category, Value parameter,

-// and ::reference type to an appropriate old-style category.

-//

-// Due to changeset 21683, this now never results in a category convertible

-// to output_iterator_tag.

-//

-// Change at: https://svn.boost.org/trac/boost/changeset/21683

-template <class Traversal, class ValueParam, class Reference>

-struct iterator_facade_default_category

-  : mpl::eval_if<

-        mpl::and_<

-            is_reference<Reference>

-          , is_convertible<Traversal,forward_traversal_tag>

-        >

-      , mpl::eval_if<

-            is_convertible<Traversal,random_access_traversal_tag>

-          , mpl::identity<std::random_access_iterator_tag>

-          , mpl::if_<

-                is_convertible<Traversal,bidirectional_traversal_tag>

-              , std::bidirectional_iterator_tag

-              , std::forward_iterator_tag

-            >

-        >

-      , typename mpl::eval_if<

-            mpl::and_<

-                is_convertible<Traversal, single_pass_traversal_tag>

-

-                // check for readability

-              , is_convertible<Reference, ValueParam>

-            >

-          , mpl::identity<std::input_iterator_tag>

-          , mpl::identity<Traversal>

-        >

-    >

-{

-};

-

-// True iff T is convertible to an old-style iterator category.

-template <class T>

-struct is_iterator_category

-  : mpl::or_<

-        is_convertible<T,std::input_iterator_tag>

-      , is_convertible<T,std::output_iterator_tag>

-    >

-{

-};

-

-template <class T>

-struct is_iterator_traversal

-  : is_convertible<T,incrementable_traversal_tag>

-{};

-

-//

-// A composite iterator_category tag convertible to Category (a pure

-// old-style category) and Traversal (a pure traversal tag).

-// Traversal must be a strict increase of the traversal power given by

-// Category.

-//

-template <class Category, class Traversal>

-struct iterator_category_with_traversal

-  : Category, Traversal

-{

-    // Make sure this isn't used to build any categories where

-    // convertibility to Traversal is redundant.  Should just use the

-    // Category element in that case.

-    BOOST_MPL_ASSERT_NOT((

-        is_convertible<

-              typename iterator_category_to_traversal<Category>::type

-            , Traversal

-          >));

-

-    BOOST_MPL_ASSERT((is_iterator_category<Category>));

-    BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));

-    BOOST_MPL_ASSERT_NOT((is_iterator_traversal<Category>));

-#  if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))

-    BOOST_MPL_ASSERT((is_iterator_traversal<Traversal>));

-#  endif

-};

-

-// Computes an iterator_category tag whose traversal is Traversal and

-// which is appropriate for an iterator

-template <class Traversal, class ValueParam, class Reference>

-struct facade_iterator_category_impl

-{

-    BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));

-

-    typedef typename iterator_facade_default_category<

-        Traversal,ValueParam,Reference

-    >::type category;

-

-    typedef typename mpl::if_<

-        is_same<

-            Traversal

-          , typename iterator_category_to_traversal<category>::type

-        >

-      , category

-      , iterator_category_with_traversal<category,Traversal>

-    >::type type;

-};

-

-//

-// Compute an iterator_category for iterator_facade

-//

-template <class CategoryOrTraversal, class ValueParam, class Reference>

-struct facade_iterator_category

-  : mpl::eval_if<

-        is_iterator_category<CategoryOrTraversal>

-      , mpl::identity<CategoryOrTraversal> // old-style categories are fine as-is

-      , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>

-    >

-{

-};

-

-}}} // namespace boost::iterators::detail

-

-# include <boost/iterator/detail/config_undef.hpp>

-

-#endif // FACADE_ITERATOR_CATEGORY_DWA20031118_HPP

+// Copyright David Abrahams 2003. Use, modification and distribution is
+// subject to the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef FACADE_ITERATOR_CATEGORY_DWA20031118_HPP
+# define FACADE_ITERATOR_CATEGORY_DWA20031118_HPP
+
+# include <boost/iterator/iterator_categories.hpp>
+
+# 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/identity.hpp>
+# include <boost/mpl/assert.hpp>
+
+# include <boost/type_traits/is_same.hpp>
+# include <boost/type_traits/is_const.hpp>
+# include <boost/type_traits/is_reference.hpp>
+# include <boost/type_traits/is_convertible.hpp>
+
+# include <boost/type_traits/is_same.hpp>
+
+# 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>
+# endif
+
+//
+// iterator_category deduction for iterator_facade
+//
+
+namespace boost {
+namespace iterators {
+
+// forward declaration
+struct use_default;
+
+namespace detail {
+
+struct input_output_iterator_tag
+  : std::input_iterator_tag
+{
+    // Using inheritance for only input_iterator_tag helps to avoid
+    // ambiguities when a stdlib implementation dispatches on a
+    // function which is overloaded on both input_iterator_tag and
+    // output_iterator_tag, as STLPort does, in its __valid_range
+    // function.  I claim it's better to avoid the ambiguity in these
+    // cases.
+    operator std::output_iterator_tag() const
+    {
+        return std::output_iterator_tag();
+    }
+};
+
+//
+// True iff the user has explicitly disabled writability of this
+// iterator.  Pass the iterator_facade's Value parameter and its
+// nested ::reference type.
+//
+template <class ValueParam, class Reference>
+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>
+      , is_const<ValueParam>
+    >
+# else
+  : is_const<ValueParam>
+# endif
+{};
+
+
+//
+// Convert an iterator_facade's traversal category, Value parameter,
+// and ::reference type to an appropriate old-style category.
+//
+// Due to changeset 21683, this now never results in a category convertible
+// to output_iterator_tag.
+//
+// Change at: https://svn.boost.org/trac/boost/changeset/21683
+template <class Traversal, class ValueParam, class Reference>
+struct iterator_facade_default_category
+  : mpl::eval_if<
+        mpl::and_<
+            is_reference<Reference>
+          , is_convertible<Traversal,forward_traversal_tag>
+        >
+      , mpl::eval_if<
+            is_convertible<Traversal,random_access_traversal_tag>
+          , mpl::identity<std::random_access_iterator_tag>
+          , mpl::if_<
+                is_convertible<Traversal,bidirectional_traversal_tag>
+              , std::bidirectional_iterator_tag
+              , std::forward_iterator_tag
+            >
+        >
+      , typename mpl::eval_if<
+            mpl::and_<
+                is_convertible<Traversal, single_pass_traversal_tag>
+
+                // check for readability
+              , is_convertible<Reference, ValueParam>
+            >
+          , mpl::identity<std::input_iterator_tag>
+          , mpl::identity<Traversal>
+        >
+    >
+{
+};
+
+// True iff T is convertible to an old-style iterator category.
+template <class T>
+struct is_iterator_category
+  : mpl::or_<
+        is_convertible<T,std::input_iterator_tag>
+      , is_convertible<T,std::output_iterator_tag>
+    >
+{
+};
+
+template <class T>
+struct is_iterator_traversal
+  : is_convertible<T,incrementable_traversal_tag>
+{};
+
+//
+// A composite iterator_category tag convertible to Category (a pure
+// old-style category) and Traversal (a pure traversal tag).
+// Traversal must be a strict increase of the traversal power given by
+// Category.
+//
+template <class Category, class Traversal>
+struct iterator_category_with_traversal
+  : Category, Traversal
+{
+    // Make sure this isn't used to build any categories where
+    // convertibility to Traversal is redundant.  Should just use the
+    // Category element in that case.
+    BOOST_MPL_ASSERT_NOT((
+        is_convertible<
+              typename iterator_category_to_traversal<Category>::type
+            , Traversal
+          >));
+
+    BOOST_MPL_ASSERT((is_iterator_category<Category>));
+    BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
+    BOOST_MPL_ASSERT_NOT((is_iterator_traversal<Category>));
+#  if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
+    BOOST_MPL_ASSERT((is_iterator_traversal<Traversal>));
+#  endif
+};
+
+// Computes an iterator_category tag whose traversal is Traversal and
+// which is appropriate for an iterator
+template <class Traversal, class ValueParam, class Reference>
+struct facade_iterator_category_impl
+{
+    BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
+
+    typedef typename iterator_facade_default_category<
+        Traversal,ValueParam,Reference
+    >::type category;
+
+    typedef typename mpl::if_<
+        is_same<
+            Traversal
+          , typename iterator_category_to_traversal<category>::type
+        >
+      , category
+      , iterator_category_with_traversal<category,Traversal>
+    >::type type;
+};
+
+//
+// Compute an iterator_category for iterator_facade
+//
+template <class CategoryOrTraversal, class ValueParam, class Reference>
+struct facade_iterator_category
+  : mpl::eval_if<
+        is_iterator_category<CategoryOrTraversal>
+      , mpl::identity<CategoryOrTraversal> // old-style categories are fine as-is
+      , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>
+    >
+{
+};
+
+}}} // namespace boost::iterators::detail
+
+# include <boost/iterator/detail/config_undef.hpp>
+
+#endif // FACADE_ITERATOR_CATEGORY_DWA20031118_HPP
diff --git a/contrib/src/boost/iterator/interoperable.hpp b/contrib/src/boost/iterator/interoperable.hpp
index 00cfb25..6f3c872 100644
--- a/contrib/src/boost/iterator/interoperable.hpp
+++ b/contrib/src/boost/iterator/interoperable.hpp
@@ -1,54 +1,54 @@
-// (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)

-#ifndef BOOST_INTEROPERABLE_23022003THW_HPP

-# define BOOST_INTEROPERABLE_23022003THW_HPP

-

-# include <boost/mpl/bool.hpp>

-# include <boost/mpl/or.hpp>

-

-# include <boost/type_traits/is_convertible.hpp>

-

-# include <boost/iterator/detail/config_def.hpp> // must appear last

-

-namespace boost {

-namespace iterators {

-

-  //

-  // Meta function that determines whether two

-  // iterator types are considered interoperable.

-  //

-  // Two iterator types A,B are considered interoperable if either

-  // A is convertible to B or vice versa.

-  // This interoperability definition is in sync with the

-  // standards requirements on constant/mutable container

-  // iterators (23.1 [lib.container.requirements]).

-  //

-  // For compilers that don't support is_convertible

-  // is_interoperable gives false positives. See comments

-  // on operator implementation for consequences.

-  //

-  template <typename A, typename B>

-  struct is_interoperable

-# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY

-    : mpl::true_

-# else

-    : mpl::or_<

-          is_convertible< A, B >

-        , is_convertible< B, A > >

-# endif

-  {

-  };

-

-} // namespace iterators

-

-using iterators::is_interoperable;

-

-} // namespace boost

-

-# include <boost/iterator/detail/config_undef.hpp>

-

-#endif // BOOST_INTEROPERABLE_23022003THW_HPP

+// (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)
+#ifndef BOOST_INTEROPERABLE_23022003THW_HPP
+# define BOOST_INTEROPERABLE_23022003THW_HPP
+
+# include <boost/mpl/bool.hpp>
+# include <boost/mpl/or.hpp>
+
+# include <boost/type_traits/is_convertible.hpp>
+
+# include <boost/iterator/detail/config_def.hpp> // must appear last
+
+namespace boost {
+namespace iterators {
+
+  //
+  // Meta function that determines whether two
+  // iterator types are considered interoperable.
+  //
+  // Two iterator types A,B are considered interoperable if either
+  // A is convertible to B or vice versa.
+  // This interoperability definition is in sync with the
+  // standards requirements on constant/mutable container
+  // iterators (23.1 [lib.container.requirements]).
+  //
+  // For compilers that don't support is_convertible
+  // is_interoperable gives false positives. See comments
+  // on operator implementation for consequences.
+  //
+  template <typename A, typename B>
+  struct is_interoperable
+# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+    : mpl::true_
+# else
+    : mpl::or_<
+          is_convertible< A, B >
+        , is_convertible< B, A > >
+# endif
+  {
+  };
+
+} // namespace iterators
+
+using iterators::is_interoperable;
+
+} // namespace boost
+
+# include <boost/iterator/detail/config_undef.hpp>
+
+#endif // BOOST_INTEROPERABLE_23022003THW_HPP
diff --git a/contrib/src/boost/iterator/iterator_adaptor.hpp b/contrib/src/boost/iterator/iterator_adaptor.hpp
index e0ed8b6..87cfd05 100644
--- a/contrib/src/boost/iterator/iterator_adaptor.hpp
+++ b/contrib/src/boost/iterator/iterator_adaptor.hpp
@@ -1,360 +1,360 @@
-// (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)

-#ifndef BOOST_ITERATOR_ADAPTOR_23022003THW_HPP

-#define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP

-

-#include <boost/static_assert.hpp>

-#include <boost/iterator.hpp>

-#include <boost/detail/iterator.hpp>

-

-#include <boost/iterator/iterator_categories.hpp>

-#include <boost/iterator/iterator_facade.hpp>

-#include <boost/iterator/detail/enable_if.hpp>

-

-#include <boost/mpl/and.hpp>

-#include <boost/mpl/not.hpp>

-#include <boost/mpl/or.hpp>

-

-#include <boost/type_traits/is_same.hpp>

-#include <boost/type_traits/is_convertible.hpp>

-

-#ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY

-# include <boost/type_traits/remove_reference.hpp>

-#endif

-

-#include <boost/type_traits/add_reference.hpp>

-#include <boost/iterator/detail/config_def.hpp>

-

-#include <boost/iterator/iterator_traits.hpp>

-

-namespace boost {

-namespace iterators {

-

-  // Used as a default template argument internally, merely to

-  // indicate "use the default", this can also be passed by users

-  // explicitly in order to specify that the default should be used.

-  struct use_default;

-

-} // namespace iterators

-

-using iterators::use_default;

-

-// the incompleteness of use_default causes massive problems for

-// is_convertible (naturally).  This workaround is fortunately not

-// needed for vc6/vc7.

-template<class To>

-struct is_convertible<use_default,To>

-  : mpl::false_ {};

-

-namespace iterators {

-

-  namespace detail

-  {

-

-    //

-    // Result type used in enable_if_convertible meta function.

-    // This can be an incomplete type, as only pointers to

-    // enable_if_convertible< ... >::type are used.

-    // We could have used void for this, but conversion to

-    // void* is just to easy.

-    //

-    struct enable_type;

-  }

-

-

-  //

-  // enable_if for use in adapted iterators constructors.

-  //

-  // In order to provide interoperability between adapted constant and

-  // mutable iterators, adapted iterators will usually provide templated

-  // conversion constructors of the following form

-  //

-  // template <class BaseIterator>

-  // class adapted_iterator :

-  //   public iterator_adaptor< adapted_iterator<Iterator>, Iterator >

-  // {

-  // public:

-  //

-  //   ...

-  //

-  //   template <class OtherIterator>

-  //   adapted_iterator(

-  //       OtherIterator const& it

-  //     , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0);

-  //

-  //   ...

-  // };

-  //

-  // enable_if_convertible is used to remove those overloads from the overload

-  // set that cannot be instantiated. For all practical purposes only overloads

-  // for constant/mutable interaction will remain. This has the advantage that

-  // meta functions like boost::is_convertible do not return false positives,

-  // as they can only look at the signature of the conversion constructor

-  // and not at the actual instantiation.

-  //

-  // enable_if_interoperable can be safely used in user code. It falls back to

-  // always enabled for compilers that don't support enable_if or is_convertible.

-  // There is no need for compiler specific workarounds in user code.

-  //

-  // The operators implementation relies on boost::is_convertible not returning

-  // false positives for user/library defined iterator types. See comments

-  // on operator implementation for consequences.

-  //

-#  if defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)

-

-  template <class From, class To>

-  struct enable_if_convertible

-  {

-      typedef boost::iterators::detail::enable_type type;

-  };

-

-#  elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292))

-

-  // For some reason vc7.1 needs us to "cut off" instantiation

-  // of is_convertible in a few cases.

-  template<typename From, typename To>

-  struct enable_if_convertible

-    : iterators::enable_if<

-        mpl::or_<

-            is_same<From,To>

-          , is_convertible<From, To>

-        >

-      , boost::iterators::detail::enable_type

-    >

-  {};

-

-#  else

-

-  template<typename From, typename To>

-  struct enable_if_convertible

-    : iterators::enable_if<

-          is_convertible<From, To>

-        , boost::iterators::detail::enable_type

-      >

-  {};

-

-# endif

-

-  //

-  // Default template argument handling for iterator_adaptor

-  //

-  namespace detail

-  {

-    // If T is use_default, return the result of invoking

-    // DefaultNullaryFn, otherwise return T.

-    template <class T, class DefaultNullaryFn>

-    struct ia_dflt_help

-      : mpl::eval_if<

-            is_same<T, use_default>

-          , DefaultNullaryFn

-          , mpl::identity<T>

-        >

-    {

-    };

-

-    // A metafunction which computes an iterator_adaptor's base class,

-    // a specialization of iterator_facade.

-    template <

-        class Derived

-      , class Base

-      , class Value

-      , class Traversal

-      , class Reference

-      , class Difference

-    >

-    struct iterator_adaptor_base

-    {

-        typedef iterator_facade<

-            Derived

-

-# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY

-          , typename boost::iterators::detail::ia_dflt_help<

-                Value

-              , mpl::eval_if<

-                    is_same<Reference,use_default>

-                  , iterator_value<Base>

-                  , remove_reference<Reference>

-                >

-            >::type

-# else

-          , typename boost::iterators::detail::ia_dflt_help<

-                Value, iterator_value<Base>

-            >::type

-# endif

-

-          , typename boost::iterators::detail::ia_dflt_help<

-                Traversal

-              , iterator_traversal<Base>

-            >::type

-

-          , typename boost::iterators::detail::ia_dflt_help<

-                Reference

-              , mpl::eval_if<

-                    is_same<Value,use_default>

-                  , iterator_reference<Base>

-                  , add_reference<Value>

-                >

-            >::type

-

-          , typename boost::iterators::detail::ia_dflt_help<

-                Difference, iterator_difference<Base>

-            >::type

-        >

-        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));

-    }

-  }

-

-  //

-  // Iterator Adaptor

-  //

-  // The parameter ordering changed slightly with respect to former

-  // versions of iterator_adaptor The idea is that when the user needs

-  // to fiddle with the reference type it is highly likely that the

-  // iterator category has to be adjusted as well.  Any of the

-  // following four template arguments may be ommitted or explicitly

-  // replaced by use_default.

-  //

-  //   Value - if supplied, the value_type of the resulting iterator, unless

-  //      const. If const, a conforming compiler strips constness for the

-  //      value_type. If not supplied, iterator_traits<Base>::value_type is used

-  //

-  //   Category - the traversal category of the resulting iterator. If not

-  //      supplied, iterator_traversal<Base>::type is used.

-  //

-  //   Reference - the reference type of the resulting iterator, and in

-  //      particular, the result type of operator*(). If not supplied but

-  //      Value is supplied, Value& is used. Otherwise

-  //      iterator_traits<Base>::reference is used.

-  //

-  //   Difference - the difference_type of the resulting iterator. If not

-  //      supplied, iterator_traits<Base>::difference_type is used.

-  //

-  template <

-      class Derived

-    , class Base

-    , class Value        = use_default

-    , class Traversal    = use_default

-    , class Reference    = use_default

-    , class Difference   = use_default

-  >

-  class iterator_adaptor

-    : public boost::iterators::detail::iterator_adaptor_base<

-        Derived, Base, Value, Traversal, Reference, Difference

-      >::type

-  {

-      friend class iterator_core_access;

-

-   protected:

-      typedef typename boost::iterators::detail::iterator_adaptor_base<

-          Derived, Base, Value, Traversal, Reference, Difference

-      >::type super_t;

-   public:

-      iterator_adaptor() {}

-

-      explicit iterator_adaptor(Base const &iter)

-          : m_iterator(iter)

-      {

-      }

-

-      typedef Base base_type;

-

-      Base const& base() const

-        { return m_iterator; }

-

-   protected:

-      // for convenience in derived classes

-      typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_;

-

-      //

-      // lvalue access to the Base object for Derived

-      //

-      Base const& base_reference() const

-        { return m_iterator; }

-

-      Base& base_reference()

-        { return m_iterator; }

-

-   private:

-      //

-      // Core iterator interface for iterator_facade.  This is private

-      // to prevent temptation for Derived classes to use it, which

-      // will often result in an error.  Derived classes should use

-      // base_reference(), above, to get direct access to m_iterator.

-      //

-      typename super_t::reference dereference() const

-        { return *m_iterator; }

-

-      template <

-      class OtherDerived, class OtherIterator, class V, class C, class R, class D

-      >

-      bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const

-      {

-        // Maybe readd with same_distance

-        //           BOOST_STATIC_ASSERT(

-        //               (detail::same_category_and_difference<Derived,OtherDerived>::value)

-        //               );

-          return m_iterator == x.base();

-      }

-

-      typedef typename iterator_category_to_traversal<

-          typename super_t::iterator_category

-      >::type my_traversal;

-

-# define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \

-      boost::iterators::detail::iterator_adaptor_assert_traversal<my_traversal, cat>();

-

-      void advance(typename super_t::difference_type n)

-      {

-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)

-          m_iterator += n;

-      }

-

-      void increment() { ++m_iterator; }

-

-      void decrement()

-      {

-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(bidirectional_traversal_tag)

-           --m_iterator;

-      }

-

-      template <

-          class OtherDerived, class OtherIterator, class V, class C, class R, class D

-      >

-      typename super_t::difference_type distance_to(

-          iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const

-      {

-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)

-          // Maybe readd with same_distance

-          //           BOOST_STATIC_ASSERT(

-          //               (detail::same_category_and_difference<Derived,OtherDerived>::value)

-          //               );

-          return y.base() - m_iterator;

-      }

-

-# undef BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL

-

-   private: // data members

-      Base m_iterator;

-  };

-

-} // namespace iterators

-

-using iterators::iterator_adaptor;

-using iterators::enable_if_convertible;

-

-} // namespace boost

-

-#include <boost/iterator/detail/config_undef.hpp>

-

-#endif // BOOST_ITERATOR_ADAPTOR_23022003THW_HPP

+// (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)
+#ifndef BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
+#define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
+
+#include <boost/static_assert.hpp>
+#include <boost/iterator.hpp>
+#include <boost/detail/iterator.hpp>
+
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/detail/enable_if.hpp>
+
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/or.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+
+#ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
+# include <boost/type_traits/remove_reference.hpp>
+#endif
+
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/iterator/detail/config_def.hpp>
+
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost {
+namespace iterators {
+
+  // Used as a default template argument internally, merely to
+  // indicate "use the default", this can also be passed by users
+  // explicitly in order to specify that the default should be used.
+  struct use_default;
+
+} // namespace iterators
+
+using iterators::use_default;
+
+// the incompleteness of use_default causes massive problems for
+// is_convertible (naturally).  This workaround is fortunately not
+// needed for vc6/vc7.
+template<class To>
+struct is_convertible<use_default,To>
+  : mpl::false_ {};
+
+namespace iterators {
+
+  namespace detail
+  {
+
+    //
+    // Result type used in enable_if_convertible meta function.
+    // This can be an incomplete type, as only pointers to
+    // enable_if_convertible< ... >::type are used.
+    // We could have used void for this, but conversion to
+    // void* is just to easy.
+    //
+    struct enable_type;
+  }
+
+
+  //
+  // enable_if for use in adapted iterators constructors.
+  //
+  // In order to provide interoperability between adapted constant and
+  // mutable iterators, adapted iterators will usually provide templated
+  // conversion constructors of the following form
+  //
+  // template <class BaseIterator>
+  // class adapted_iterator :
+  //   public iterator_adaptor< adapted_iterator<Iterator>, Iterator >
+  // {
+  // public:
+  //
+  //   ...
+  //
+  //   template <class OtherIterator>
+  //   adapted_iterator(
+  //       OtherIterator const& it
+  //     , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0);
+  //
+  //   ...
+  // };
+  //
+  // enable_if_convertible is used to remove those overloads from the overload
+  // set that cannot be instantiated. For all practical purposes only overloads
+  // for constant/mutable interaction will remain. This has the advantage that
+  // meta functions like boost::is_convertible do not return false positives,
+  // as they can only look at the signature of the conversion constructor
+  // and not at the actual instantiation.
+  //
+  // enable_if_interoperable can be safely used in user code. It falls back to
+  // always enabled for compilers that don't support enable_if or is_convertible.
+  // There is no need for compiler specific workarounds in user code.
+  //
+  // The operators implementation relies on boost::is_convertible not returning
+  // false positives for user/library defined iterator types. See comments
+  // on operator implementation for consequences.
+  //
+#  if defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
+
+  template <class From, class To>
+  struct enable_if_convertible
+  {
+      typedef boost::iterators::detail::enable_type type;
+  };
+
+#  elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292))
+
+  // For some reason vc7.1 needs us to "cut off" instantiation
+  // of is_convertible in a few cases.
+  template<typename From, typename To>
+  struct enable_if_convertible
+    : iterators::enable_if<
+        mpl::or_<
+            is_same<From,To>
+          , is_convertible<From, To>
+        >
+      , boost::iterators::detail::enable_type
+    >
+  {};
+
+#  else
+
+  template<typename From, typename To>
+  struct enable_if_convertible
+    : iterators::enable_if<
+          is_convertible<From, To>
+        , boost::iterators::detail::enable_type
+      >
+  {};
+
+# endif
+
+  //
+  // Default template argument handling for iterator_adaptor
+  //
+  namespace detail
+  {
+    // If T is use_default, return the result of invoking
+    // DefaultNullaryFn, otherwise return T.
+    template <class T, class DefaultNullaryFn>
+    struct ia_dflt_help
+      : mpl::eval_if<
+            is_same<T, use_default>
+          , DefaultNullaryFn
+          , mpl::identity<T>
+        >
+    {
+    };
+
+    // A metafunction which computes an iterator_adaptor's base class,
+    // a specialization of iterator_facade.
+    template <
+        class Derived
+      , class Base
+      , class Value
+      , class Traversal
+      , class Reference
+      , class Difference
+    >
+    struct iterator_adaptor_base
+    {
+        typedef iterator_facade<
+            Derived
+
+# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
+          , typename boost::iterators::detail::ia_dflt_help<
+                Value
+              , mpl::eval_if<
+                    is_same<Reference,use_default>
+                  , iterator_value<Base>
+                  , remove_reference<Reference>
+                >
+            >::type
+# else
+          , typename boost::iterators::detail::ia_dflt_help<
+                Value, iterator_value<Base>
+            >::type
+# endif
+
+          , typename boost::iterators::detail::ia_dflt_help<
+                Traversal
+              , iterator_traversal<Base>
+            >::type
+
+          , typename boost::iterators::detail::ia_dflt_help<
+                Reference
+              , mpl::eval_if<
+                    is_same<Value,use_default>
+                  , iterator_reference<Base>
+                  , add_reference<Value>
+                >
+            >::type
+
+          , typename boost::iterators::detail::ia_dflt_help<
+                Difference, iterator_difference<Base>
+            >::type
+        >
+        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));
+    }
+  }
+
+  //
+  // Iterator Adaptor
+  //
+  // The parameter ordering changed slightly with respect to former
+  // versions of iterator_adaptor The idea is that when the user needs
+  // to fiddle with the reference type it is highly likely that the
+  // iterator category has to be adjusted as well.  Any of the
+  // following four template arguments may be ommitted or explicitly
+  // replaced by use_default.
+  //
+  //   Value - if supplied, the value_type of the resulting iterator, unless
+  //      const. If const, a conforming compiler strips constness for the
+  //      value_type. If not supplied, iterator_traits<Base>::value_type is used
+  //
+  //   Category - the traversal category of the resulting iterator. If not
+  //      supplied, iterator_traversal<Base>::type is used.
+  //
+  //   Reference - the reference type of the resulting iterator, and in
+  //      particular, the result type of operator*(). If not supplied but
+  //      Value is supplied, Value& is used. Otherwise
+  //      iterator_traits<Base>::reference is used.
+  //
+  //   Difference - the difference_type of the resulting iterator. If not
+  //      supplied, iterator_traits<Base>::difference_type is used.
+  //
+  template <
+      class Derived
+    , class Base
+    , class Value        = use_default
+    , class Traversal    = use_default
+    , class Reference    = use_default
+    , class Difference   = use_default
+  >
+  class iterator_adaptor
+    : public boost::iterators::detail::iterator_adaptor_base<
+        Derived, Base, Value, Traversal, Reference, Difference
+      >::type
+  {
+      friend class iterator_core_access;
+
+   protected:
+      typedef typename boost::iterators::detail::iterator_adaptor_base<
+          Derived, Base, Value, Traversal, Reference, Difference
+      >::type super_t;
+   public:
+      iterator_adaptor() {}
+
+      explicit iterator_adaptor(Base const &iter)
+          : m_iterator(iter)
+      {
+      }
+
+      typedef Base base_type;
+
+      Base const& base() const
+        { return m_iterator; }
+
+   protected:
+      // for convenience in derived classes
+      typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_;
+
+      //
+      // lvalue access to the Base object for Derived
+      //
+      Base const& base_reference() const
+        { return m_iterator; }
+
+      Base& base_reference()
+        { return m_iterator; }
+
+   private:
+      //
+      // Core iterator interface for iterator_facade.  This is private
+      // to prevent temptation for Derived classes to use it, which
+      // will often result in an error.  Derived classes should use
+      // base_reference(), above, to get direct access to m_iterator.
+      //
+      typename super_t::reference dereference() const
+        { return *m_iterator; }
+
+      template <
+      class OtherDerived, class OtherIterator, class V, class C, class R, class D
+      >
+      bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
+      {
+        // Maybe readd with same_distance
+        //           BOOST_STATIC_ASSERT(
+        //               (detail::same_category_and_difference<Derived,OtherDerived>::value)
+        //               );
+          return m_iterator == x.base();
+      }
+
+      typedef typename iterator_category_to_traversal<
+          typename super_t::iterator_category
+      >::type my_traversal;
+
+# define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \
+      boost::iterators::detail::iterator_adaptor_assert_traversal<my_traversal, cat>();
+
+      void advance(typename super_t::difference_type n)
+      {
+          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
+          m_iterator += n;
+      }
+
+      void increment() { ++m_iterator; }
+
+      void decrement()
+      {
+          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(bidirectional_traversal_tag)
+           --m_iterator;
+      }
+
+      template <
+          class OtherDerived, class OtherIterator, class V, class C, class R, class D
+      >
+      typename super_t::difference_type distance_to(
+          iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
+      {
+          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
+          // Maybe readd with same_distance
+          //           BOOST_STATIC_ASSERT(
+          //               (detail::same_category_and_difference<Derived,OtherDerived>::value)
+          //               );
+          return y.base() - m_iterator;
+      }
+
+# undef BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL
+
+   private: // data members
+      Base m_iterator;
+  };
+
+} // namespace iterators
+
+using iterators::iterator_adaptor;
+using iterators::enable_if_convertible;
+
+} // namespace boost
+
+#include <boost/iterator/detail/config_undef.hpp>
+
+#endif // BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
diff --git a/contrib/src/boost/iterator/iterator_categories.hpp b/contrib/src/boost/iterator/iterator_categories.hpp
index e052b67..71202c9 100644
--- a/contrib/src/boost/iterator/iterator_categories.hpp
+++ b/contrib/src/boost/iterator/iterator_categories.hpp
@@ -1,215 +1,215 @@
-// (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)

-

-#ifndef BOOST_ITERATOR_CATEGORIES_HPP

-# define BOOST_ITERATOR_CATEGORIES_HPP

-

-# include <boost/config.hpp>

-# include <boost/detail/iterator.hpp>

-# include <boost/iterator/detail/config_def.hpp>

-

-# include <boost/detail/workaround.hpp>

-

-# include <boost/mpl/eval_if.hpp>

-# include <boost/mpl/identity.hpp>

-# include <boost/mpl/placeholders.hpp>

-# include <boost/mpl/aux_/lambda_support.hpp>

-

-# include <boost/type_traits/is_convertible.hpp>

-

-# include <boost/static_assert.hpp>

-

-namespace boost {

-namespace iterators {

-

-//

-// Traversal Categories

-//

-

-struct no_traversal_tag {};

-

-struct incrementable_traversal_tag

-  : no_traversal_tag

-{

-//     incrementable_traversal_tag() {}

-//     incrementable_traversal_tag(std::output_iterator_tag const&) {};

-};

-

-struct single_pass_traversal_tag

-  : incrementable_traversal_tag

-{

-//     single_pass_traversal_tag() {}

-//     single_pass_traversal_tag(std::input_iterator_tag const&) {};

-};

-

-struct forward_traversal_tag

-  : single_pass_traversal_tag

-{

-//     forward_traversal_tag() {}

-//     forward_traversal_tag(std::forward_iterator_tag const&) {};

-};

-

-struct bidirectional_traversal_tag

-  : forward_traversal_tag

-{

-//     bidirectional_traversal_tag() {};

-//     bidirectional_traversal_tag(std::bidirectional_iterator_tag const&) {};

-};

-

-struct random_access_traversal_tag

-  : bidirectional_traversal_tag

-{

-//     random_access_traversal_tag() {};

-//     random_access_traversal_tag(std::random_access_iterator_tag const&) {};

-};

-

-namespace detail

-{

-  //

-  // Convert a "strictly old-style" iterator category to a traversal

-  // tag.  This is broken out into a separate metafunction to reduce

-  // the cost of instantiating iterator_category_to_traversal, below,

-  // for new-style types.

-  //

-  template <class Cat>

-  struct old_category_to_traversal

-    : mpl::eval_if<

-          is_convertible<Cat,std::random_access_iterator_tag>

-        , mpl::identity<random_access_traversal_tag>

-        , mpl::eval_if<

-              is_convertible<Cat,std::bidirectional_iterator_tag>

-            , mpl::identity<bidirectional_traversal_tag>

-            , mpl::eval_if<

-                  is_convertible<Cat,std::forward_iterator_tag>

-                , mpl::identity<forward_traversal_tag>

-                , mpl::eval_if<

-                      is_convertible<Cat,std::input_iterator_tag>

-                    , mpl::identity<single_pass_traversal_tag>

-                    , mpl::eval_if<

-                          is_convertible<Cat,std::output_iterator_tag>

-                        , mpl::identity<incrementable_traversal_tag>

-                        , void

-                      >

-                  >

-              >

-          >

-      >

-  {};

-

-} // namespace detail

-

-//

-// Convert an iterator category into a traversal tag

-//

-template <class Cat>

-struct iterator_category_to_traversal

-  : mpl::eval_if< // if already convertible to a traversal tag, we're done.

-        is_convertible<Cat,incrementable_traversal_tag>

-      , mpl::identity<Cat>

-      , boost::iterators::detail::old_category_to_traversal<Cat>

-    >

-{};

-

-// Trait to get an iterator's traversal category

-template <class Iterator = mpl::_1>

-struct iterator_traversal

-  : iterator_category_to_traversal<

-        typename boost::detail::iterator_traits<Iterator>::iterator_category

-    >

-{};

-

-# ifdef BOOST_MPL_CFG_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

-// placeholder. Instead we just specialize it as a metafunction

-// class.

-template <>

-struct iterator_traversal<mpl::_1>

-{

-    template <class T>

-    struct apply : iterator_traversal<T>

-    {};

-};

-template <>

-struct iterator_traversal<mpl::_>

-  : iterator_traversal<mpl::_1>

-{};

-# endif

-

-//

-// Convert an iterator traversal to one of the traversal tags.

-//

-template <class Traversal>

-struct pure_traversal_tag

-  : mpl::eval_if<

-        is_convertible<Traversal,random_access_traversal_tag>

-      , mpl::identity<random_access_traversal_tag>

-      , mpl::eval_if<

-            is_convertible<Traversal,bidirectional_traversal_tag>

-          , mpl::identity<bidirectional_traversal_tag>

-          , mpl::eval_if<

-                is_convertible<Traversal,forward_traversal_tag>

-              , mpl::identity<forward_traversal_tag>

-              , mpl::eval_if<

-                    is_convertible<Traversal,single_pass_traversal_tag>

-                  , mpl::identity<single_pass_traversal_tag>

-                  , mpl::eval_if<

-                        is_convertible<Traversal,incrementable_traversal_tag>

-                      , mpl::identity<incrementable_traversal_tag>

-                      , void

-                    >

-                >

-            >

-        >

-    >

-{

-};

-

-//

-// Trait to retrieve one of the iterator traversal tags from the iterator category or traversal.

-//

-template <class Iterator = mpl::_1>

-struct pure_iterator_traversal

-  : pure_traversal_tag<typename iterator_traversal<Iterator>::type>

-{};

-

-# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT

-template <>

-struct pure_iterator_traversal<mpl::_1>

-{

-    template <class T>

-    struct apply : pure_iterator_traversal<T>

-    {};

-};

-template <>

-struct pure_iterator_traversal<mpl::_>

-  : pure_iterator_traversal<mpl::_1>

-{};

-# endif

-

-} // namespace iterators

-

-using iterators::no_traversal_tag;

-using iterators::incrementable_traversal_tag;

-using iterators::single_pass_traversal_tag;

-using iterators::forward_traversal_tag;

-using iterators::bidirectional_traversal_tag;

-using iterators::random_access_traversal_tag;

-using iterators::iterator_category_to_traversal;

-using iterators::iterator_traversal;

-

-// This import is needed for backward compatibility with Boost.Range:

-// boost/range/detail/demote_iterator_traversal_tag.hpp

-// It should be removed when that header is fixed.

-namespace detail {

-using iterators::pure_traversal_tag;

-} // namespace detail

-

-} // namespace boost

-

-#include <boost/iterator/detail/config_undef.hpp>

-

-#endif // BOOST_ITERATOR_CATEGORIES_HPP

+// (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)
+
+#ifndef BOOST_ITERATOR_CATEGORIES_HPP
+# define BOOST_ITERATOR_CATEGORIES_HPP
+
+# include <boost/config.hpp>
+# include <boost/detail/iterator.hpp>
+# include <boost/iterator/detail/config_def.hpp>
+
+# include <boost/detail/workaround.hpp>
+
+# include <boost/mpl/eval_if.hpp>
+# include <boost/mpl/identity.hpp>
+# include <boost/mpl/placeholders.hpp>
+# include <boost/mpl/aux_/lambda_support.hpp>
+
+# include <boost/type_traits/is_convertible.hpp>
+
+# include <boost/static_assert.hpp>
+
+namespace boost {
+namespace iterators {
+
+//
+// Traversal Categories
+//
+
+struct no_traversal_tag {};
+
+struct incrementable_traversal_tag
+  : no_traversal_tag
+{
+//     incrementable_traversal_tag() {}
+//     incrementable_traversal_tag(std::output_iterator_tag const&) {};
+};
+
+struct single_pass_traversal_tag
+  : incrementable_traversal_tag
+{
+//     single_pass_traversal_tag() {}
+//     single_pass_traversal_tag(std::input_iterator_tag const&) {};
+};
+
+struct forward_traversal_tag
+  : single_pass_traversal_tag
+{
+//     forward_traversal_tag() {}
+//     forward_traversal_tag(std::forward_iterator_tag const&) {};
+};
+
+struct bidirectional_traversal_tag
+  : forward_traversal_tag
+{
+//     bidirectional_traversal_tag() {};
+//     bidirectional_traversal_tag(std::bidirectional_iterator_tag const&) {};
+};
+
+struct random_access_traversal_tag
+  : bidirectional_traversal_tag
+{
+//     random_access_traversal_tag() {};
+//     random_access_traversal_tag(std::random_access_iterator_tag const&) {};
+};
+
+namespace detail
+{
+  //
+  // Convert a "strictly old-style" iterator category to a traversal
+  // tag.  This is broken out into a separate metafunction to reduce
+  // the cost of instantiating iterator_category_to_traversal, below,
+  // for new-style types.
+  //
+  template <class Cat>
+  struct old_category_to_traversal
+    : mpl::eval_if<
+          is_convertible<Cat,std::random_access_iterator_tag>
+        , mpl::identity<random_access_traversal_tag>
+        , mpl::eval_if<
+              is_convertible<Cat,std::bidirectional_iterator_tag>
+            , mpl::identity<bidirectional_traversal_tag>
+            , mpl::eval_if<
+                  is_convertible<Cat,std::forward_iterator_tag>
+                , mpl::identity<forward_traversal_tag>
+                , mpl::eval_if<
+                      is_convertible<Cat,std::input_iterator_tag>
+                    , mpl::identity<single_pass_traversal_tag>
+                    , mpl::eval_if<
+                          is_convertible<Cat,std::output_iterator_tag>
+                        , mpl::identity<incrementable_traversal_tag>
+                        , void
+                      >
+                  >
+              >
+          >
+      >
+  {};
+
+} // namespace detail
+
+//
+// Convert an iterator category into a traversal tag
+//
+template <class Cat>
+struct iterator_category_to_traversal
+  : mpl::eval_if< // if already convertible to a traversal tag, we're done.
+        is_convertible<Cat,incrementable_traversal_tag>
+      , mpl::identity<Cat>
+      , boost::iterators::detail::old_category_to_traversal<Cat>
+    >
+{};
+
+// Trait to get an iterator's traversal category
+template <class Iterator = mpl::_1>
+struct iterator_traversal
+  : iterator_category_to_traversal<
+        typename boost::detail::iterator_traits<Iterator>::iterator_category
+    >
+{};
+
+# ifdef BOOST_MPL_CFG_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
+// placeholder. Instead we just specialize it as a metafunction
+// class.
+template <>
+struct iterator_traversal<mpl::_1>
+{
+    template <class T>
+    struct apply : iterator_traversal<T>
+    {};
+};
+template <>
+struct iterator_traversal<mpl::_>
+  : iterator_traversal<mpl::_1>
+{};
+# endif
+
+//
+// Convert an iterator traversal to one of the traversal tags.
+//
+template <class Traversal>
+struct pure_traversal_tag
+  : mpl::eval_if<
+        is_convertible<Traversal,random_access_traversal_tag>
+      , mpl::identity<random_access_traversal_tag>
+      , mpl::eval_if<
+            is_convertible<Traversal,bidirectional_traversal_tag>
+          , mpl::identity<bidirectional_traversal_tag>
+          , mpl::eval_if<
+                is_convertible<Traversal,forward_traversal_tag>
+              , mpl::identity<forward_traversal_tag>
+              , mpl::eval_if<
+                    is_convertible<Traversal,single_pass_traversal_tag>
+                  , mpl::identity<single_pass_traversal_tag>
+                  , mpl::eval_if<
+                        is_convertible<Traversal,incrementable_traversal_tag>
+                      , mpl::identity<incrementable_traversal_tag>
+                      , void
+                    >
+                >
+            >
+        >
+    >
+{
+};
+
+//
+// Trait to retrieve one of the iterator traversal tags from the iterator category or traversal.
+//
+template <class Iterator = mpl::_1>
+struct pure_iterator_traversal
+  : pure_traversal_tag<typename iterator_traversal<Iterator>::type>
+{};
+
+# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
+template <>
+struct pure_iterator_traversal<mpl::_1>
+{
+    template <class T>
+    struct apply : pure_iterator_traversal<T>
+    {};
+};
+template <>
+struct pure_iterator_traversal<mpl::_>
+  : pure_iterator_traversal<mpl::_1>
+{};
+# endif
+
+} // namespace iterators
+
+using iterators::no_traversal_tag;
+using iterators::incrementable_traversal_tag;
+using iterators::single_pass_traversal_tag;
+using iterators::forward_traversal_tag;
+using iterators::bidirectional_traversal_tag;
+using iterators::random_access_traversal_tag;
+using iterators::iterator_category_to_traversal;
+using iterators::iterator_traversal;
+
+// This import is needed for backward compatibility with Boost.Range:
+// boost/range/detail/demote_iterator_traversal_tag.hpp
+// It should be removed when that header is fixed.
+namespace detail {
+using iterators::pure_traversal_tag;
+} // namespace detail
+
+} // namespace boost
+
+#include <boost/iterator/detail/config_undef.hpp>
+
+#endif // BOOST_ITERATOR_CATEGORIES_HPP
diff --git a/contrib/src/boost/iterator/iterator_concepts.hpp b/contrib/src/boost/iterator/iterator_concepts.hpp
index e9479f6..1a9f7d6 100644
--- a/contrib/src/boost/iterator/iterator_concepts.hpp
+++ b/contrib/src/boost/iterator/iterator_concepts.hpp
@@ -1,275 +1,275 @@
-// (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)

-

-#ifndef BOOST_ITERATOR_CONCEPTS_HPP

-#define BOOST_ITERATOR_CONCEPTS_HPP

-

-#include <boost/concept_check.hpp>

-#include <boost/iterator/iterator_categories.hpp>

-

-// Use boost::detail::iterator_traits to work around some MSVC/Dinkumware problems.

-#include <boost/detail/iterator.hpp>

-

-#include <boost/type_traits/is_same.hpp>

-#include <boost/type_traits/is_integral.hpp>

-

-#include <boost/mpl/bool.hpp>

-#include <boost/mpl/if.hpp>

-#include <boost/mpl/and.hpp>

-#include <boost/mpl/or.hpp>

-

-#include <boost/static_assert.hpp>

-

-// Use boost/limits to work around missing limits headers on some compilers

-#include <boost/limits.hpp>

-#include <boost/config.hpp>

-

-#include <algorithm>

-

-#include <boost/concept/detail/concept_def.hpp>

-

-namespace boost_concepts

-{

-  // Used a different namespace here (instead of "boost") so that the

-  // concept descriptions do not take for granted the names in

-  // namespace boost.

-

-  //===========================================================================

-  // Iterator Access Concepts

-

-  BOOST_concept(ReadableIterator,(Iterator))

-    : boost::Assignable<Iterator>

-    , boost::CopyConstructible<Iterator>

-

-  {

-      typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type value_type;

-      typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference reference;

-

-      BOOST_CONCEPT_USAGE(ReadableIterator)

-      {

-

-          value_type v = *i;

-          boost::ignore_unused_variable_warning(v);

-      }

-  private:

-      Iterator i;

-  };

-

-  template <

-      typename Iterator

-    , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type

-  >

-  struct WritableIterator

-    : boost::CopyConstructible<Iterator>

-  {

-      BOOST_CONCEPT_USAGE(WritableIterator)

-      {

-          *i = v;

-      }

-  private:

-      ValueType v;

-      Iterator i;

-  };

-

-  template <

-      typename Iterator

-    , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type

-  >

-  struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};

-

-  BOOST_concept(SwappableIterator,(Iterator))

-  {

-      BOOST_CONCEPT_USAGE(SwappableIterator)

-      {

-          std::iter_swap(i1, i2);

-      }

-  private:

-      Iterator i1;

-      Iterator i2;

-  };

-

-  BOOST_concept(LvalueIterator,(Iterator))

-  {

-      typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;

-

-      BOOST_CONCEPT_USAGE(LvalueIterator)

-      {

-        value_type& r = const_cast<value_type&>(*i);

-        boost::ignore_unused_variable_warning(r);

-      }

-  private:

-      Iterator i;

-  };

-

-

-  //===========================================================================

-  // Iterator Traversal Concepts

-

-  BOOST_concept(IncrementableIterator,(Iterator))

-    : boost::Assignable<Iterator>

-    , boost::CopyConstructible<Iterator>

-  {

-      typedef typename boost::iterator_traversal<Iterator>::type traversal_category;

-

-      BOOST_CONCEPT_ASSERT((

-        boost::Convertible<

-            traversal_category

-          , boost::incrementable_traversal_tag

-        >));

-

-      BOOST_CONCEPT_USAGE(IncrementableIterator)

-      {

-          ++i;

-          (void)i++;

-      }

-  private:

-      Iterator i;

-  };

-

-  BOOST_concept(SinglePassIterator,(Iterator))

-    : IncrementableIterator<Iterator>

-    , boost::EqualityComparable<Iterator>

-

-  {

-      BOOST_CONCEPT_ASSERT((

-          boost::Convertible<

-             BOOST_DEDUCED_TYPENAME SinglePassIterator::traversal_category

-           , boost::single_pass_traversal_tag

-          > ));

-  };

-

-  BOOST_concept(ForwardTraversal,(Iterator))

-    : SinglePassIterator<Iterator>

-    , boost::DefaultConstructible<Iterator>

-  {

-      typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;

-

-      BOOST_MPL_ASSERT((boost::is_integral<difference_type>));

-      BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);

-

-      BOOST_CONCEPT_ASSERT((

-          boost::Convertible<

-             BOOST_DEDUCED_TYPENAME ForwardTraversal::traversal_category

-           , boost::forward_traversal_tag

-          > ));

-  };

-

-  BOOST_concept(BidirectionalTraversal,(Iterator))

-    : ForwardTraversal<Iterator>

-  {

-      BOOST_CONCEPT_ASSERT((

-          boost::Convertible<

-             BOOST_DEDUCED_TYPENAME BidirectionalTraversal::traversal_category

-           , boost::bidirectional_traversal_tag

-          > ));

-

-      BOOST_CONCEPT_USAGE(BidirectionalTraversal)

-      {

-          --i;

-          (void)i--;

-      }

-   private:

-      Iterator i;

-  };

-

-  BOOST_concept(RandomAccessTraversal,(Iterator))

-    : BidirectionalTraversal<Iterator>

-  {

-      BOOST_CONCEPT_ASSERT((

-          boost::Convertible<

-             BOOST_DEDUCED_TYPENAME RandomAccessTraversal::traversal_category

-           , boost::random_access_traversal_tag

-          > ));

-

-      BOOST_CONCEPT_USAGE(RandomAccessTraversal)

-      {

-          i += n;

-          i = i + n;

-          i = n + i;

-          i -= n;

-          i = i - n;

-          n = i - j;

-      }

-

-   private:

-      typename BidirectionalTraversal<Iterator>::difference_type n;

-      Iterator i, j;

-  };

-

-  //===========================================================================

-  // Iterator Interoperability

-

-  namespace detail

-  {

-    template <typename Iterator1, typename Iterator2>

-    void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2)

-    {

-        bool b;

-        b = i1 == i2;

-        b = i1 != i2;

-

-        b = i2 == i1;

-        b = i2 != i1;

-        boost::ignore_unused_variable_warning(b);

-    }

-

-    template <typename Iterator1, typename Iterator2>

-    void interop_rand_access_constraints(

-        Iterator1 const& i1, Iterator2 const& i2,

-        boost::random_access_traversal_tag, boost::random_access_traversal_tag)

-    {

-        bool b;

-        typename boost::detail::iterator_traits<Iterator2>::difference_type n;

-        b = i1 <  i2;

-        b = i1 <= i2;

-        b = i1 >  i2;

-        b = i1 >= i2;

-        n = i1 -  i2;

-

-        b = i2 <  i1;

-        b = i2 <= i1;

-        b = i2 >  i1;

-        b = i2 >= i1;

-        n = i2 -  i1;

-        boost::ignore_unused_variable_warning(b);

-        boost::ignore_unused_variable_warning(n);

-    }

-

-    template <typename Iterator1, typename Iterator2>

-    void interop_rand_access_constraints(

-        Iterator1 const&, Iterator2 const&,

-        boost::single_pass_traversal_tag, boost::single_pass_traversal_tag)

-    { }

-

-  } // namespace detail

-

-  BOOST_concept(InteroperableIterator,(Iterator)(ConstIterator))

-  {

-   private:

-      typedef typename boost::iterators::pure_iterator_traversal<Iterator>::type traversal_category;

-      typedef typename boost::iterators::pure_iterator_traversal<ConstIterator>::type const_traversal_category;

-

-   public:

-      BOOST_CONCEPT_ASSERT((SinglePassIterator<Iterator>));

-      BOOST_CONCEPT_ASSERT((SinglePassIterator<ConstIterator>));

-

-      BOOST_CONCEPT_USAGE(InteroperableIterator)

-      {

-          detail::interop_single_pass_constraints(i, ci);

-          detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());

-

-          ci = i;

-      }

-

-   private:

-      Iterator      i;

-      ConstIterator ci;

-  };

-

-} // namespace boost_concepts

-

-#include <boost/concept/detail/concept_undef.hpp>

-

-#endif // BOOST_ITERATOR_CONCEPTS_HPP

+// (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)
+
+#ifndef BOOST_ITERATOR_CONCEPTS_HPP
+#define BOOST_ITERATOR_CONCEPTS_HPP
+
+#include <boost/concept_check.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+// Use boost::detail::iterator_traits to work around some MSVC/Dinkumware problems.
+#include <boost/detail/iterator.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_integral.hpp>
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/or.hpp>
+
+#include <boost/static_assert.hpp>
+
+// Use boost/limits to work around missing limits headers on some compilers
+#include <boost/limits.hpp>
+#include <boost/config.hpp>
+
+#include <algorithm>
+
+#include <boost/concept/detail/concept_def.hpp>
+
+namespace boost_concepts
+{
+  // Used a different namespace here (instead of "boost") so that the
+  // concept descriptions do not take for granted the names in
+  // namespace boost.
+
+  //===========================================================================
+  // Iterator Access Concepts
+
+  BOOST_concept(ReadableIterator,(Iterator))
+    : boost::Assignable<Iterator>
+    , boost::CopyConstructible<Iterator>
+
+  {
+      typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type value_type;
+      typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference reference;
+
+      BOOST_CONCEPT_USAGE(ReadableIterator)
+      {
+
+          value_type v = *i;
+          boost::ignore_unused_variable_warning(v);
+      }
+  private:
+      Iterator i;
+  };
+
+  template <
+      typename Iterator
+    , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
+  >
+  struct WritableIterator
+    : boost::CopyConstructible<Iterator>
+  {
+      BOOST_CONCEPT_USAGE(WritableIterator)
+      {
+          *i = v;
+      }
+  private:
+      ValueType v;
+      Iterator i;
+  };
+
+  template <
+      typename Iterator
+    , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
+  >
+  struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
+
+  BOOST_concept(SwappableIterator,(Iterator))
+  {
+      BOOST_CONCEPT_USAGE(SwappableIterator)
+      {
+          std::iter_swap(i1, i2);
+      }
+  private:
+      Iterator i1;
+      Iterator i2;
+  };
+
+  BOOST_concept(LvalueIterator,(Iterator))
+  {
+      typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
+
+      BOOST_CONCEPT_USAGE(LvalueIterator)
+      {
+        value_type& r = const_cast<value_type&>(*i);
+        boost::ignore_unused_variable_warning(r);
+      }
+  private:
+      Iterator i;
+  };
+
+
+  //===========================================================================
+  // Iterator Traversal Concepts
+
+  BOOST_concept(IncrementableIterator,(Iterator))
+    : boost::Assignable<Iterator>
+    , boost::CopyConstructible<Iterator>
+  {
+      typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
+
+      BOOST_CONCEPT_ASSERT((
+        boost::Convertible<
+            traversal_category
+          , boost::incrementable_traversal_tag
+        >));
+
+      BOOST_CONCEPT_USAGE(IncrementableIterator)
+      {
+          ++i;
+          (void)i++;
+      }
+  private:
+      Iterator i;
+  };
+
+  BOOST_concept(SinglePassIterator,(Iterator))
+    : IncrementableIterator<Iterator>
+    , boost::EqualityComparable<Iterator>
+
+  {
+      BOOST_CONCEPT_ASSERT((
+          boost::Convertible<
+             BOOST_DEDUCED_TYPENAME SinglePassIterator::traversal_category
+           , boost::single_pass_traversal_tag
+          > ));
+  };
+
+  BOOST_concept(ForwardTraversal,(Iterator))
+    : SinglePassIterator<Iterator>
+    , boost::DefaultConstructible<Iterator>
+  {
+      typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
+
+      BOOST_MPL_ASSERT((boost::is_integral<difference_type>));
+      BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
+
+      BOOST_CONCEPT_ASSERT((
+          boost::Convertible<
+             BOOST_DEDUCED_TYPENAME ForwardTraversal::traversal_category
+           , boost::forward_traversal_tag
+          > ));
+  };
+
+  BOOST_concept(BidirectionalTraversal,(Iterator))
+    : ForwardTraversal<Iterator>
+  {
+      BOOST_CONCEPT_ASSERT((
+          boost::Convertible<
+             BOOST_DEDUCED_TYPENAME BidirectionalTraversal::traversal_category
+           , boost::bidirectional_traversal_tag
+          > ));
+
+      BOOST_CONCEPT_USAGE(BidirectionalTraversal)
+      {
+          --i;
+          (void)i--;
+      }
+   private:
+      Iterator i;
+  };
+
+  BOOST_concept(RandomAccessTraversal,(Iterator))
+    : BidirectionalTraversal<Iterator>
+  {
+      BOOST_CONCEPT_ASSERT((
+          boost::Convertible<
+             BOOST_DEDUCED_TYPENAME RandomAccessTraversal::traversal_category
+           , boost::random_access_traversal_tag
+          > ));
+
+      BOOST_CONCEPT_USAGE(RandomAccessTraversal)
+      {
+          i += n;
+          i = i + n;
+          i = n + i;
+          i -= n;
+          i = i - n;
+          n = i - j;
+      }
+
+   private:
+      typename BidirectionalTraversal<Iterator>::difference_type n;
+      Iterator i, j;
+  };
+
+  //===========================================================================
+  // Iterator Interoperability
+
+  namespace detail
+  {
+    template <typename Iterator1, typename Iterator2>
+    void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2)
+    {
+        bool b;
+        b = i1 == i2;
+        b = i1 != i2;
+
+        b = i2 == i1;
+        b = i2 != i1;
+        boost::ignore_unused_variable_warning(b);
+    }
+
+    template <typename Iterator1, typename Iterator2>
+    void interop_rand_access_constraints(
+        Iterator1 const& i1, Iterator2 const& i2,
+        boost::random_access_traversal_tag, boost::random_access_traversal_tag)
+    {
+        bool b;
+        typename boost::detail::iterator_traits<Iterator2>::difference_type n;
+        b = i1 <  i2;
+        b = i1 <= i2;
+        b = i1 >  i2;
+        b = i1 >= i2;
+        n = i1 -  i2;
+
+        b = i2 <  i1;
+        b = i2 <= i1;
+        b = i2 >  i1;
+        b = i2 >= i1;
+        n = i2 -  i1;
+        boost::ignore_unused_variable_warning(b);
+        boost::ignore_unused_variable_warning(n);
+    }
+
+    template <typename Iterator1, typename Iterator2>
+    void interop_rand_access_constraints(
+        Iterator1 const&, Iterator2 const&,
+        boost::single_pass_traversal_tag, boost::single_pass_traversal_tag)
+    { }
+
+  } // namespace detail
+
+  BOOST_concept(InteroperableIterator,(Iterator)(ConstIterator))
+  {
+   private:
+      typedef typename boost::iterators::pure_iterator_traversal<Iterator>::type traversal_category;
+      typedef typename boost::iterators::pure_iterator_traversal<ConstIterator>::type const_traversal_category;
+
+   public:
+      BOOST_CONCEPT_ASSERT((SinglePassIterator<Iterator>));
+      BOOST_CONCEPT_ASSERT((SinglePassIterator<ConstIterator>));
+
+      BOOST_CONCEPT_USAGE(InteroperableIterator)
+      {
+          detail::interop_single_pass_constraints(i, ci);
+          detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());
+
+          ci = i;
+      }
+
+   private:
+      Iterator      i;
+      ConstIterator ci;
+  };
+
+} // namespace boost_concepts
+
+#include <boost/concept/detail/concept_undef.hpp>
+
+#endif // BOOST_ITERATOR_CONCEPTS_HPP
diff --git a/contrib/src/boost/iterator/iterator_facade.hpp b/contrib/src/boost/iterator/iterator_facade.hpp
index 1bb8bd9..7b11d0a 100644
--- a/contrib/src/boost/iterator/iterator_facade.hpp
+++ b/contrib/src/boost/iterator/iterator_facade.hpp
@@ -1,980 +1,980 @@
-// (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)

-#ifndef BOOST_ITERATOR_FACADE_23022003THW_HPP

-#define BOOST_ITERATOR_FACADE_23022003THW_HPP

-

-#include <boost/config.hpp>

-#include <boost/iterator.hpp>

-#include <boost/iterator/interoperable.hpp>

-#include <boost/iterator/iterator_traits.hpp>

-#include <boost/iterator/iterator_categories.hpp>

-

-#include <boost/iterator/detail/facade_iterator_category.hpp>

-#include <boost/iterator/detail/enable_if.hpp>

-

-#include <boost/static_assert.hpp>

-#include <boost/utility/addressof.hpp>

-

-#include <boost/type_traits/is_same.hpp>

-#include <boost/type_traits/add_const.hpp>

-#include <boost/type_traits/add_pointer.hpp>

-#include <boost/type_traits/add_lvalue_reference.hpp>

-#include <boost/type_traits/remove_const.hpp>

-#include <boost/type_traits/remove_reference.hpp>

-#include <boost/type_traits/is_convertible.hpp>

-#include <boost/type_traits/is_pod.hpp>

-

-#include <boost/mpl/eval_if.hpp>

-#include <boost/mpl/if.hpp>

-#include <boost/mpl/or.hpp>

-#include <boost/mpl/and.hpp>

-#include <boost/mpl/not.hpp>

-#include <boost/mpl/always.hpp>

-#include <boost/mpl/apply.hpp>

-#include <boost/mpl/identity.hpp>

-

-#include <boost/iterator/detail/config_def.hpp> // this goes last

-

-namespace boost {

-namespace iterators {

-

-  // This forward declaration is required for the friend declaration

-  // in iterator_core_access

-  template <class I, class V, class TC, class R, class D> class iterator_facade;

-

-  namespace detail

-  {

-    // A binary metafunction class that always returns bool.  VC6

-    // ICEs on mpl::always<bool>, probably because of the default

-    // parameters.

-    struct always_bool2

-    {

-        template <class T, class U>

-        struct apply

-        {

-            typedef bool type;

-        };

-    };

-

-    // The type trait checks if the category or traversal is at least as advanced as the specified required traversal

-    template< typename CategoryOrTraversal, typename Required >

-    struct is_traversal_at_least :

-        public boost::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required >

-    {};

-

-    //

-    // enable if for use in operator implementation.

-    //

-    template <

-        class Facade1

-      , class Facade2

-      , class Return

-    >

-    struct enable_if_interoperable :

-        public boost::iterators::enable_if<

-            is_interoperable< Facade1, Facade2 >

-          , Return

-        >

-    {};

-

-    //

-    // enable if for use in implementation of operators specific for random access traversal.

-    //

-    template <

-        class Facade1

-      , class Facade2

-      , class Return

-    >

-    struct enable_if_interoperable_and_random_access_traversal :

-        public boost::iterators::enable_if<

-            mpl::and_<

-                is_interoperable< Facade1, Facade2 >

-              , is_traversal_at_least< typename iterator_category< Facade1 >::type, random_access_traversal_tag >

-              , is_traversal_at_least< typename iterator_category< Facade2 >::type, random_access_traversal_tag >

-            >

-          , Return

-        >

-    {};

-

-    //

-    // Generates associated types for an iterator_facade with the

-    // given parameters.

-    //

-    template <

-        class ValueParam

-      , class CategoryOrTraversal

-      , class Reference

-      , class Difference

-    >

-    struct iterator_facade_types

-    {

-        typedef typename facade_iterator_category<

-            CategoryOrTraversal, ValueParam, Reference

-        >::type iterator_category;

-

-        typedef typename remove_const<ValueParam>::type value_type;

-

-        // Not the real associated pointer type

-        typedef typename mpl::eval_if<

-            boost::iterators::detail::iterator_writability_disabled<ValueParam,Reference>

-          , add_pointer<const value_type>

-          , add_pointer<value_type>

-        >::type pointer;

-

-# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                          \

-    && (BOOST_WORKAROUND(_STLPORT_VERSION, BOOST_TESTED_AT(0x452))              \

-        || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, BOOST_TESTED_AT(310)))     \

-    || BOOST_WORKAROUND(BOOST_RWSTD_VER, BOOST_TESTED_AT(0x20101))              \

-    || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 310)

-

-        // To interoperate with some broken library/compiler

-        // combinations, user-defined iterators must be derived from

-        // std::iterator.  It is possible to implement a standard

-        // library for broken compilers without this limitation.

-#  define BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE 1

-

-        typedef

-           iterator<iterator_category, value_type, Difference, pointer, Reference>

-        base;

-# endif

-    };

-

-    // iterators whose dereference operators reference the same value

-    // for all iterators into the same sequence (like many input

-    // iterators) need help with their postfix ++: the referenced

-    // value must be read and stored away before the increment occurs

-    // so that *a++ yields the originally referenced element and not

-    // the next one.

-    template <class Iterator>

-    class postfix_increment_proxy

-    {

-        typedef typename iterator_value<Iterator>::type value_type;

-     public:

-        explicit postfix_increment_proxy(Iterator const& x)

-          : stored_value(*x)

-        {}

-

-        // Returning a mutable reference allows nonsense like

-        // (*r++).mutate(), but it imposes fewer assumptions about the

-        // behavior of the value_type.  In particular, recall that

-        // (*r).mutate() is legal if operator* returns by value.

-        value_type&

-        operator*() const

-        {

-            return this->stored_value;

-        }

-     private:

-        mutable value_type stored_value;

-    };

-

-    //

-    // In general, we can't determine that such an iterator isn't

-    // writable -- we also need to store a copy of the old iterator so

-    // that it can be written into.

-    template <class Iterator>

-    class writable_postfix_increment_proxy

-    {

-        typedef typename iterator_value<Iterator>::type value_type;

-     public:

-        explicit writable_postfix_increment_proxy(Iterator const& x)

-          : stored_value(*x)

-          , stored_iterator(x)

-        {}

-

-        // Dereferencing must return a proxy so that both *r++ = o and

-        // value_type(*r++) can work.  In this case, *r is the same as

-        // *r++, and the conversion operator below is used to ensure

-        // readability.

-        writable_postfix_increment_proxy const&

-        operator*() const

-        {

-            return *this;

-        }

-

-        // Provides readability of *r++

-        operator value_type&() const

-        {

-            return stored_value;

-        }

-

-        // Provides writability of *r++

-        template <class T>

-        T const& operator=(T const& x) const

-        {

-            *this->stored_iterator = x;

-            return x;

-        }

-

-        // This overload just in case only non-const objects are writable

-        template <class T>

-        T& operator=(T& x) const

-        {

-            *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;

-    };

-

-# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

-

-    template <class Reference, class Value>

-    struct is_non_proxy_reference_impl

-    {

-        static Reference r;

-

-        template <class R>

-        static typename mpl::if_<

-            is_convertible<

-                R const volatile*

-              , Value const volatile*

-            >

-          , char[1]

-          , char[2]

-        >::type& helper(R const&);

-

-        BOOST_STATIC_CONSTANT(bool, value = sizeof(helper(r)) == 1);

-    };

-

-    template <class Reference, class Value>

-    struct is_non_proxy_reference

-      : mpl::bool_<

-            is_non_proxy_reference_impl<Reference, Value>::value

-        >

-    {};

-# else

-    template <class Reference, class Value>

-    struct is_non_proxy_reference

-      : is_convertible<

-            typename remove_reference<Reference>::type

-            const volatile*

-          , Value const volatile*

-        >

-    {};

-# endif

-

-    // A metafunction to choose the result type of postfix ++

-    //

-    // Because the C++98 input iterator requirements say that *r++ has

-    // type T (value_type), implementations of some standard

-    // algorithms like lexicographical_compare may use constructions

-    // like:

-    //

-    //          *r++ < *s++

-    //

-    // If *r++ returns a proxy (as required if r is writable but not

-    // multipass), this sort of expression will fail unless the proxy

-    // supports the operator<.  Since there are any number of such

-    // operations, we're not going to try to support them.  Therefore,

-    // even if r++ returns a proxy, *r++ will only return a proxy if

-    // *r also returns a proxy.

-    template <class Iterator, class Value, class Reference, class CategoryOrTraversal>

-    struct postfix_increment_result

-      : mpl::eval_if<

-            mpl::and_<

-                // A proxy is only needed for readable iterators

-                is_convertible<

-                    Reference

-                    // Use add_lvalue_reference to form `reference to Value` due to

-                    // some (strict) C++03 compilers (e.g. `gcc -std=c++03`) reject

-                    // 'reference-to-reference' in the template which described in CWG

-                    // DR106.

-                    // http://www.open-std.org/Jtc1/sc22/wg21/docs/cwg_defects.html#106

-                  , typename add_lvalue_reference<Value const>::type

-                >

-

-                // No multipass iterator can have values that disappear

-                // before positions can be re-visited

-              , mpl::not_<

-                    is_convertible<

-                        typename iterator_category_to_traversal<CategoryOrTraversal>::type

-                      , forward_traversal_tag

-                    >

-                >

-            >

-          , mpl::if_<

-                is_non_proxy_reference<Reference,Value>

-              , postfix_increment_proxy<Iterator>

-              , writable_postfix_increment_proxy<Iterator>

-            >

-          , mpl::identity<Iterator>

-        >

-    {};

-

-    // operator->() needs special support for input iterators to strictly meet the

-    // standard's requirements. If *i is not a reference type, we must still

-    // produce an lvalue to which a pointer can be formed.  We do that by

-    // returning a proxy object containing an instance of the reference object.

-    template <class Reference, class Pointer>

-    struct operator_arrow_dispatch // proxy references

-    {

-        struct proxy

-        {

-            explicit proxy(Reference const & x) : m_ref(x) {}

-            Reference* operator->() { return boost::addressof(m_ref); }

-            // This function is needed for MWCW and BCC, which won't call

-            // operator-> again automatically per 13.3.1.2 para 8

-            operator Reference*() { return boost::addressof(m_ref); }

-            Reference m_ref;

-        };

-        typedef proxy result_type;

-        static result_type apply(Reference const & x)

-        {

-            return result_type(x);

-        }

-    };

-

-    template <class T, class Pointer>

-    struct operator_arrow_dispatch<T&, Pointer> // "real" references

-    {

-        typedef Pointer result_type;

-        static result_type apply(T& x)

-        {

-            return boost::addressof(x);

-        }

-    };

-

-    // A proxy return type for operator[], needed to deal with

-    // iterators that may invalidate referents upon destruction.

-    // Consider the temporary iterator in *(a + n)

-    template <class Iterator>

-    class operator_brackets_proxy

-    {

-        // Iterator is actually an iterator_facade, so we do not have to

-        // go through iterator_traits to access the traits.

-        typedef typename Iterator::reference  reference;

-        typedef typename Iterator::value_type value_type;

-

-     public:

-        operator_brackets_proxy(Iterator const& iter)

-          : m_iter(iter)

-        {}

-

-        operator reference() const

-        {

-            return *m_iter;

-        }

-

-        operator_brackets_proxy& operator=(value_type const& val)

-        {

-            *m_iter = val;

-            return *this;

-        }

-

-     private:

-        Iterator m_iter;

-    };

-

-    // A metafunction that determines whether operator[] must return a

-    // proxy, or whether it can simply return a copy of the value_type.

-    template <class ValueType, class Reference>

-    struct use_operator_brackets_proxy

-      : mpl::not_<

-            mpl::and_<

-                // Really we want an is_copy_constructible trait here,

-                // but is_POD will have to suffice in the meantime.

-                boost::is_POD<ValueType>

-              , iterator_writability_disabled<ValueType,Reference>

-            >

-        >

-    {};

-

-    template <class Iterator, class Value, class Reference>

-    struct operator_brackets_result

-    {

-        typedef typename mpl::if_<

-            use_operator_brackets_proxy<Value,Reference>

-          , operator_brackets_proxy<Iterator>

-          , Value

-        >::type type;

-    };

-

-    template <class Iterator>

-    operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::true_)

-    {

-        return operator_brackets_proxy<Iterator>(iter);

-    }

-

-    template <class Iterator>

-    typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_)

-    {

-      return *iter;

-    }

-

-    struct choose_difference_type

-    {

-        template <class I1, class I2>

-        struct apply

-          :

-# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP

-          iterator_difference<I1>

-# else

-          mpl::eval_if<

-              is_convertible<I2,I1>

-            , iterator_difference<I1>

-            , iterator_difference<I2>

-          >

-# endif

-        {};

-

-    };

-

-    template <

-        class Derived

-      , class Value

-      , class CategoryOrTraversal

-      , class Reference

-      , class Difference

-      , bool IsBidirectionalTraversal

-      , bool IsRandomAccessTraversal

-    >

-    class iterator_facade_base;

-

-  } // namespace detail

-

-

-  // Macros which describe the declarations of binary operators

-# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY

-#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler)       \

-    template <                                                              \

-        class Derived1, class V1, class TC1, class Reference1, class Difference1 \

-      , class Derived2, class V2, class TC2, class Reference2, class Difference2 \

-    >                                                                       \

-    prefix typename mpl::apply2<result_type,Derived1,Derived2>::type \

-    operator op(                                                            \

-        iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs   \

-      , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)

-# else

-#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler)   \

-    template <                                                          \

-        class Derived1, class V1, class TC1, class Reference1, class Difference1 \

-      , class Derived2, class V2, class TC2, class Reference2, class Difference2 \

-    >                                                                   \

-    prefix typename enabler<                                            \

-        Derived1, Derived2                                              \

-      , typename mpl::apply2<result_type,Derived1,Derived2>::type       \

-    >::type                                                             \

-    operator op(                                                        \

-        iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs   \

-      , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)

-# endif

-

-#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)       \

-    BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable)

-

-#  define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(prefix, op, result_type)       \

-    BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable_and_random_access_traversal)

-

-#  define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args)              \

-    template <class Derived, class V, class TC, class R, class D>   \

-    prefix typename boost::iterators::enable_if<                    \

-        boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >,  \

-        Derived                                                     \

-    >::type operator+ args

-

-  //

-  // Helper class for granting access to the iterator core interface.

-  //

-  // The simple core interface is used by iterator_facade. The core

-  // interface of a user/library defined iterator type should not be made public

-  // so that it does not clutter the public interface. Instead iterator_core_access

-  // should be made friend so that iterator_facade can access the core

-  // interface through iterator_core_access.

-  //

-  class iterator_core_access

-  {

-# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)

-      // Tasteless as this may seem, making all members public allows member templates

-      // to work in the absence of member template friends.

-   public:

-# else

-

-      template <class I, class V, class TC, class R, class D> friend class iterator_facade;

-      template <class I, class V, class TC, class R, class D, bool IsBidirectionalTraversal, bool IsRandomAccessTraversal>

-      friend class detail::iterator_facade_base;

-

-#  define BOOST_ITERATOR_FACADE_RELATION(op)                                \

-      BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::iterators::detail::always_bool2);

-

-      BOOST_ITERATOR_FACADE_RELATION(==)

-      BOOST_ITERATOR_FACADE_RELATION(!=)

-

-#  undef BOOST_ITERATOR_FACADE_RELATION

-

-#  define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op)                                \

-      BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(friend,op, boost::iterators::detail::always_bool2);

-

-      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<)

-      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>)

-      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=)

-      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=)

-

-#  undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION

-

-      BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(

-          friend, -, boost::iterators::detail::choose_difference_type)

-      ;

-

-      BOOST_ITERATOR_FACADE_PLUS_HEAD(

-          friend inline

-        , (iterator_facade<Derived, V, TC, R, D> const&

-        , typename Derived::difference_type)

-      )

-      ;

-

-      BOOST_ITERATOR_FACADE_PLUS_HEAD(

-          friend inline

-        , (typename Derived::difference_type

-        , iterator_facade<Derived, V, TC, R, D> const&)

-      )

-      ;

-

-# endif

-

-      template <class Facade>

-      static typename Facade::reference dereference(Facade const& f)

-      {

-          return f.dereference();

-      }

-

-      template <class Facade>

-      static void increment(Facade& f)

-      {

-          f.increment();

-      }

-

-      template <class Facade>

-      static void decrement(Facade& f)

-      {

-          f.decrement();

-      }

-

-      template <class Facade1, class Facade2>

-      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)

-      {

-          return f1.equal(f2);

-      }

-

-      template <class Facade1, class Facade2>

-      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)

-      {

-          return f2.equal(f1);

-      }

-

-      template <class Facade>

-      static void advance(Facade& f, typename Facade::difference_type n)

-      {

-          f.advance(n);

-      }

-

-      template <class Facade1, class Facade2>

-      static typename Facade1::difference_type distance_from(

-          Facade1 const& f1, Facade2 const& f2, mpl::true_)

-      {

-          return -f1.distance_to(f2);

-      }

-

-      template <class Facade1, class Facade2>

-      static typename Facade2::difference_type distance_from(

-          Facade1 const& f1, Facade2 const& f2, mpl::false_)

-      {

-          return f2.distance_to(f1);

-      }

-

-      //

-      // Curiously Recurring Template interface.

-      //

-      template <class I, class V, class TC, class R, class D>

-      static I& derived(iterator_facade<I,V,TC,R,D>& facade)

-      {

-          return *static_cast<I*>(&facade);

-      }

-

-      template <class I, class V, class TC, class R, class D>

-      static I const& derived(iterator_facade<I,V,TC,R,D> const& facade)

-      {

-          return *static_cast<I const*>(&facade);

-      }

-

-      // objects of this class are useless

-      BOOST_DELETED_FUNCTION(iterator_core_access())

-  };

-

-  namespace detail {

-

-    // Implementation for forward traversal iterators

-    template <

-        class Derived

-      , class Value

-      , class CategoryOrTraversal

-      , class Reference

-      , class Difference

-    >

-    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >

-# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE

-        : public boost::iterators::detail::iterator_facade_types<

-             Value, CategoryOrTraversal, Reference, Difference

-          >::base

-#  undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE

-# endif

-    {

-    private:

-        typedef boost::iterators::detail::iterator_facade_types<

-            Value, CategoryOrTraversal, Reference, Difference

-        > associated_types;

-

-        typedef boost::iterators::detail::operator_arrow_dispatch<

-            Reference

-          , typename associated_types::pointer

-        > operator_arrow_dispatch_;

-

-    public:

-        typedef typename associated_types::value_type value_type;

-        typedef Reference reference;

-        typedef Difference difference_type;

-

-        typedef typename operator_arrow_dispatch_::result_type pointer;

-

-        typedef typename associated_types::iterator_category iterator_category;

-

-    public:

-        reference operator*() const

-        {

-            return iterator_core_access::dereference(this->derived());

-        }

-

-        pointer operator->() const

-        {

-            return operator_arrow_dispatch_::apply(*this->derived());

-        }

-

-        Derived& operator++()

-        {

-            iterator_core_access::increment(this->derived());

-            return this->derived();

-        }

-

-    protected:

-        //

-        // Curiously Recurring Template interface.

-        //

-        Derived& derived()

-        {

-            return *static_cast<Derived*>(this);

-        }

-

-        Derived const& derived() const

-        {

-            return *static_cast<Derived const*>(this);

-        }

-    };

-

-    // Implementation for bidirectional traversal iterators

-    template <

-        class Derived

-      , class Value

-      , class CategoryOrTraversal

-      , class Reference

-      , class Difference

-    >

-    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > :

-        public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >

-    {

-    public:

-        Derived& operator--()

-        {

-            iterator_core_access::decrement(this->derived());

-            return this->derived();

-        }

-

-        Derived operator--(int)

-        {

-            Derived tmp(this->derived());

-            --*this;

-            return tmp;

-        }

-    };

-

-    // Implementation for random access traversal iterators

-    template <

-        class Derived

-      , class Value

-      , class CategoryOrTraversal

-      , class Reference

-      , class Difference

-    >

-    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, true > :

-        public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false >

-    {

-    private:

-        typedef iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > base_type;

-

-    public:

-        typedef typename base_type::reference reference;

-        typedef typename base_type::difference_type difference_type;

-

-    public:

-        typename boost::iterators::detail::operator_brackets_result<Derived, Value, reference>::type

-        operator[](difference_type n) const

-        {

-            typedef boost::iterators::detail::use_operator_brackets_proxy<Value, Reference> use_proxy;

-

-            return boost::iterators::detail::make_operator_brackets_result<Derived>(

-                this->derived() + n

-              , use_proxy()

-            );

-        }

-

-        Derived& operator+=(difference_type n)

-        {

-            iterator_core_access::advance(this->derived(), n);

-            return this->derived();

-        }

-

-        Derived& operator-=(difference_type n)

-        {

-            iterator_core_access::advance(this->derived(), -n);

-            return this->derived();

-        }

-

-        Derived operator-(difference_type x) const

-        {

-            Derived result(this->derived());

-            return result -= x;

-        }

-    };

-

-  } // namespace detail

-

-  //

-  // iterator_facade - use as a public base class for defining new

-  // standard-conforming iterators.

-  //

-  template <

-      class Derived             // The derived iterator type being constructed

-    , class Value

-    , class CategoryOrTraversal

-    , class Reference   = Value&

-    , class Difference  = std::ptrdiff_t

-  >

-  class iterator_facade :

-      public detail::iterator_facade_base<

-          Derived,

-          Value,

-          CategoryOrTraversal,

-          Reference,

-          Difference,

-          detail::is_traversal_at_least< CategoryOrTraversal, bidirectional_traversal_tag >::value,

-          detail::is_traversal_at_least< CategoryOrTraversal, random_access_traversal_tag >::value

-      >

-  {

-  protected:

-      // For use by derived classes

-      typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_;

-  };

-

-  template <class I, class V, class TC, class R, class D>

-  inline typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type

-  operator++(

-      iterator_facade<I,V,TC,R,D>& i

-    , int

-  )

-  {

-      typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type

-          tmp(*static_cast<I*>(&i));

-

-      ++i;

-

-      return tmp;

-  }

-

-

-  //

-  // Comparison operator implementation. The library supplied operators

-  // enables the user to provide fully interoperable constant/mutable

-  // iterator types. I.e. the library provides all operators

-  // for all mutable/constant iterator combinations.

-  //

-  // Note though that this kind of interoperability for constant/mutable

-  // iterators is not required by the standard for container iterators.

-  // All the standard asks for is a conversion mutable -> constant.

-  // Most standard library implementations nowadays provide fully interoperable

-  // iterator implementations, but there are still heavily used implementations

-  // that do not provide them. (Actually it's even worse, they do not provide

-  // them for only a few iterators.)

-  //

-  // ?? Maybe a BOOST_ITERATOR_NO_FULL_INTEROPERABILITY macro should

-  //    enable the user to turn off mixed type operators

-  //

-  // The library takes care to provide only the right operator overloads.

-  // I.e.

-  //

-  // bool operator==(Iterator,      Iterator);

-  // bool operator==(ConstIterator, Iterator);

-  // bool operator==(Iterator,      ConstIterator);

-  // bool operator==(ConstIterator, ConstIterator);

-  //

-  //   ...

-  //

-  // In order to do so it uses c++ idioms that are not yet widely supported

-  // by current compiler releases. The library is designed to degrade gracefully

-  // in the face of compiler deficiencies. In general compiler

-  // deficiencies result in less strict error checking and more obscure

-  // error messages, functionality is not affected.

-  //

-  // For full operation compiler support for "Substitution Failure Is Not An Error"

-  // (aka. enable_if) and boost::is_convertible is required.

-  //

-  // The following problems occur if support is lacking.

-  //

-  // Pseudo code

-  //

-  // ---------------

-  // AdaptorA<Iterator1> a1;

-  // AdaptorA<Iterator2> a2;

-  //

-  // // This will result in a no such overload error in full operation

-  // // If enable_if or is_convertible is not supported

-  // // The instantiation will fail with an error hopefully indicating that

-  // // there is no operator== for Iterator1, Iterator2

-  // // The same will happen if no enable_if is used to remove

-  // // false overloads from the templated conversion constructor

-  // // of AdaptorA.

-  //

-  // a1 == a2;

-  // ----------------

-  //

-  // AdaptorA<Iterator> a;

-  // AdaptorB<Iterator> b;

-  //

-  // // This will result in a no such overload error in full operation

-  // // If enable_if is not supported the static assert used

-  // // in the operator implementation will fail.

-  // // This will accidently work if is_convertible is not supported.

-  //

-  // a == b;

-  // ----------------

-  //

-

-# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP

-#  define BOOST_ITERATOR_CONVERTIBLE(a,b) mpl::true_()

-# else

-#  define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible<a,b>()

-# endif

-

-# define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, return_prefix, base_op) \

-  BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type)                   \

-  {                                                                             \

-      /* For those compilers that do not support enable_if */                   \

-      BOOST_STATIC_ASSERT((                                                     \

-          is_interoperable< Derived1, Derived2 >::value                         \

-      ));                                                                       \

-      return_prefix iterator_core_access::base_op(                              \

-          *static_cast<Derived1 const*>(&lhs)                                   \

-        , *static_cast<Derived2 const*>(&rhs)                                   \

-        , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1)                         \

-      );                                                                        \

-  }

-

-# define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \

-  BOOST_ITERATOR_FACADE_INTEROP(                                    \

-      op                                                            \

-    , boost::iterators::detail::always_bool2                                   \

-    , return_prefix                                                 \

-    , base_op                                                       \

-  )

-

-  BOOST_ITERATOR_FACADE_RELATION(==, return, equal)

-  BOOST_ITERATOR_FACADE_RELATION(!=, return !, equal)

-

-# undef BOOST_ITERATOR_FACADE_RELATION

-

-

-# define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(op, result_type, return_prefix, base_op) \

-  BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(inline, op, result_type)                   \

-  {                                                                             \

-      /* For those compilers that do not support enable_if */                   \

-      BOOST_STATIC_ASSERT((                                                     \

-          is_interoperable< Derived1, Derived2 >::value &&                      \

-          boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && \

-          boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value \

-      ));                                                                       \

-      return_prefix iterator_core_access::base_op(                              \

-          *static_cast<Derived1 const*>(&lhs)                                   \

-        , *static_cast<Derived2 const*>(&rhs)                                   \

-        , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1)                         \

-      );                                                                        \

-  }

-

-# define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op, return_prefix, base_op) \

-  BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(                                    \

-      op                                                            \

-    , boost::iterators::detail::always_bool2                                   \

-    , return_prefix                                                 \

-    , base_op                                                       \

-  )

-

-  BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<, return 0 >, distance_from)

-  BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>, return 0 <, distance_from)

-  BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=, return 0 >=, distance_from)

-  BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=, return 0 <=, distance_from)

-

-# undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION

-

-  // operator- requires an additional part in the static assertion

-  BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(

-      -

-    , boost::iterators::detail::choose_difference_type

-    , return

-    , distance_from

-  )

-

-# undef BOOST_ITERATOR_FACADE_INTEROP

-# undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS

-

-# define BOOST_ITERATOR_FACADE_PLUS(args)           \

-  BOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args)     \

-  {                                                 \

-      Derived tmp(static_cast<Derived const&>(i));  \

-      return tmp += n;                              \

-  }

-

-  BOOST_ITERATOR_FACADE_PLUS((

-      iterator_facade<Derived, V, TC, R, D> const& i

-    , typename Derived::difference_type n

-  ))

-

-  BOOST_ITERATOR_FACADE_PLUS((

-      typename Derived::difference_type n

-    , iterator_facade<Derived, V, TC, R, D> const& i

-  ))

-

-# undef BOOST_ITERATOR_FACADE_PLUS

-# undef BOOST_ITERATOR_FACADE_PLUS_HEAD

-

-# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD

-# undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD

-# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL

-

-} // namespace iterators

-

-using iterators::iterator_core_access;

-using iterators::iterator_facade;

-

-} // namespace boost

-

-#include <boost/iterator/detail/config_undef.hpp>

-

-#endif // BOOST_ITERATOR_FACADE_23022003THW_HPP

+// (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)
+#ifndef BOOST_ITERATOR_FACADE_23022003THW_HPP
+#define BOOST_ITERATOR_FACADE_23022003THW_HPP
+
+#include <boost/config.hpp>
+#include <boost/iterator.hpp>
+#include <boost/iterator/interoperable.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+#include <boost/iterator/detail/facade_iterator_category.hpp>
+#include <boost/iterator/detail/enable_if.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/utility/addressof.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/add_pointer.hpp>
+#include <boost/type_traits/add_lvalue_reference.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_pod.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/always.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/identity.hpp>
+
+#include <boost/iterator/detail/config_def.hpp> // this goes last
+
+namespace boost {
+namespace iterators {
+
+  // This forward declaration is required for the friend declaration
+  // in iterator_core_access
+  template <class I, class V, class TC, class R, class D> class iterator_facade;
+
+  namespace detail
+  {
+    // A binary metafunction class that always returns bool.  VC6
+    // ICEs on mpl::always<bool>, probably because of the default
+    // parameters.
+    struct always_bool2
+    {
+        template <class T, class U>
+        struct apply
+        {
+            typedef bool type;
+        };
+    };
+
+    // The type trait checks if the category or traversal is at least as advanced as the specified required traversal
+    template< typename CategoryOrTraversal, typename Required >
+    struct is_traversal_at_least :
+        public boost::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required >
+    {};
+
+    //
+    // enable if for use in operator implementation.
+    //
+    template <
+        class Facade1
+      , class Facade2
+      , class Return
+    >
+    struct enable_if_interoperable :
+        public boost::iterators::enable_if<
+            is_interoperable< Facade1, Facade2 >
+          , Return
+        >
+    {};
+
+    //
+    // enable if for use in implementation of operators specific for random access traversal.
+    //
+    template <
+        class Facade1
+      , class Facade2
+      , class Return
+    >
+    struct enable_if_interoperable_and_random_access_traversal :
+        public boost::iterators::enable_if<
+            mpl::and_<
+                is_interoperable< Facade1, Facade2 >
+              , is_traversal_at_least< typename iterator_category< Facade1 >::type, random_access_traversal_tag >
+              , is_traversal_at_least< typename iterator_category< Facade2 >::type, random_access_traversal_tag >
+            >
+          , Return
+        >
+    {};
+
+    //
+    // Generates associated types for an iterator_facade with the
+    // given parameters.
+    //
+    template <
+        class ValueParam
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+    >
+    struct iterator_facade_types
+    {
+        typedef typename facade_iterator_category<
+            CategoryOrTraversal, ValueParam, Reference
+        >::type iterator_category;
+
+        typedef typename remove_const<ValueParam>::type value_type;
+
+        // Not the real associated pointer type
+        typedef typename mpl::eval_if<
+            boost::iterators::detail::iterator_writability_disabled<ValueParam,Reference>
+          , add_pointer<const value_type>
+          , add_pointer<value_type>
+        >::type pointer;
+
+# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                          \
+    && (BOOST_WORKAROUND(_STLPORT_VERSION, BOOST_TESTED_AT(0x452))              \
+        || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, BOOST_TESTED_AT(310)))     \
+    || BOOST_WORKAROUND(BOOST_RWSTD_VER, BOOST_TESTED_AT(0x20101))              \
+    || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 310)
+
+        // To interoperate with some broken library/compiler
+        // combinations, user-defined iterators must be derived from
+        // std::iterator.  It is possible to implement a standard
+        // library for broken compilers without this limitation.
+#  define BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE 1
+
+        typedef
+           iterator<iterator_category, value_type, Difference, pointer, Reference>
+        base;
+# endif
+    };
+
+    // iterators whose dereference operators reference the same value
+    // for all iterators into the same sequence (like many input
+    // iterators) need help with their postfix ++: the referenced
+    // value must be read and stored away before the increment occurs
+    // so that *a++ yields the originally referenced element and not
+    // the next one.
+    template <class Iterator>
+    class postfix_increment_proxy
+    {
+        typedef typename iterator_value<Iterator>::type value_type;
+     public:
+        explicit postfix_increment_proxy(Iterator const& x)
+          : stored_value(*x)
+        {}
+
+        // Returning a mutable reference allows nonsense like
+        // (*r++).mutate(), but it imposes fewer assumptions about the
+        // behavior of the value_type.  In particular, recall that
+        // (*r).mutate() is legal if operator* returns by value.
+        value_type&
+        operator*() const
+        {
+            return this->stored_value;
+        }
+     private:
+        mutable value_type stored_value;
+    };
+
+    //
+    // In general, we can't determine that such an iterator isn't
+    // writable -- we also need to store a copy of the old iterator so
+    // that it can be written into.
+    template <class Iterator>
+    class writable_postfix_increment_proxy
+    {
+        typedef typename iterator_value<Iterator>::type value_type;
+     public:
+        explicit writable_postfix_increment_proxy(Iterator const& x)
+          : stored_value(*x)
+          , stored_iterator(x)
+        {}
+
+        // Dereferencing must return a proxy so that both *r++ = o and
+        // value_type(*r++) can work.  In this case, *r is the same as
+        // *r++, and the conversion operator below is used to ensure
+        // readability.
+        writable_postfix_increment_proxy const&
+        operator*() const
+        {
+            return *this;
+        }
+
+        // Provides readability of *r++
+        operator value_type&() const
+        {
+            return stored_value;
+        }
+
+        // Provides writability of *r++
+        template <class T>
+        T const& operator=(T const& x) const
+        {
+            *this->stored_iterator = x;
+            return x;
+        }
+
+        // This overload just in case only non-const objects are writable
+        template <class T>
+        T& operator=(T& x) const
+        {
+            *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;
+    };
+
+# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+    template <class Reference, class Value>
+    struct is_non_proxy_reference_impl
+    {
+        static Reference r;
+
+        template <class R>
+        static typename mpl::if_<
+            is_convertible<
+                R const volatile*
+              , Value const volatile*
+            >
+          , char[1]
+          , char[2]
+        >::type& helper(R const&);
+
+        BOOST_STATIC_CONSTANT(bool, value = sizeof(helper(r)) == 1);
+    };
+
+    template <class Reference, class Value>
+    struct is_non_proxy_reference
+      : mpl::bool_<
+            is_non_proxy_reference_impl<Reference, Value>::value
+        >
+    {};
+# else
+    template <class Reference, class Value>
+    struct is_non_proxy_reference
+      : is_convertible<
+            typename remove_reference<Reference>::type
+            const volatile*
+          , Value const volatile*
+        >
+    {};
+# endif
+
+    // A metafunction to choose the result type of postfix ++
+    //
+    // Because the C++98 input iterator requirements say that *r++ has
+    // type T (value_type), implementations of some standard
+    // algorithms like lexicographical_compare may use constructions
+    // like:
+    //
+    //          *r++ < *s++
+    //
+    // If *r++ returns a proxy (as required if r is writable but not
+    // multipass), this sort of expression will fail unless the proxy
+    // supports the operator<.  Since there are any number of such
+    // operations, we're not going to try to support them.  Therefore,
+    // even if r++ returns a proxy, *r++ will only return a proxy if
+    // *r also returns a proxy.
+    template <class Iterator, class Value, class Reference, class CategoryOrTraversal>
+    struct postfix_increment_result
+      : mpl::eval_if<
+            mpl::and_<
+                // A proxy is only needed for readable iterators
+                is_convertible<
+                    Reference
+                    // Use add_lvalue_reference to form `reference to Value` due to
+                    // some (strict) C++03 compilers (e.g. `gcc -std=c++03`) reject
+                    // 'reference-to-reference' in the template which described in CWG
+                    // DR106.
+                    // http://www.open-std.org/Jtc1/sc22/wg21/docs/cwg_defects.html#106
+                  , typename add_lvalue_reference<Value const>::type
+                >
+
+                // No multipass iterator can have values that disappear
+                // before positions can be re-visited
+              , mpl::not_<
+                    is_convertible<
+                        typename iterator_category_to_traversal<CategoryOrTraversal>::type
+                      , forward_traversal_tag
+                    >
+                >
+            >
+          , mpl::if_<
+                is_non_proxy_reference<Reference,Value>
+              , postfix_increment_proxy<Iterator>
+              , writable_postfix_increment_proxy<Iterator>
+            >
+          , mpl::identity<Iterator>
+        >
+    {};
+
+    // operator->() needs special support for input iterators to strictly meet the
+    // standard's requirements. If *i is not a reference type, we must still
+    // produce an lvalue to which a pointer can be formed.  We do that by
+    // returning a proxy object containing an instance of the reference object.
+    template <class Reference, class Pointer>
+    struct operator_arrow_dispatch // proxy references
+    {
+        struct proxy
+        {
+            explicit proxy(Reference const & x) : m_ref(x) {}
+            Reference* operator->() { return boost::addressof(m_ref); }
+            // This function is needed for MWCW and BCC, which won't call
+            // operator-> again automatically per 13.3.1.2 para 8
+            operator Reference*() { return boost::addressof(m_ref); }
+            Reference m_ref;
+        };
+        typedef proxy result_type;
+        static result_type apply(Reference const & x)
+        {
+            return result_type(x);
+        }
+    };
+
+    template <class T, class Pointer>
+    struct operator_arrow_dispatch<T&, Pointer> // "real" references
+    {
+        typedef Pointer result_type;
+        static result_type apply(T& x)
+        {
+            return boost::addressof(x);
+        }
+    };
+
+    // A proxy return type for operator[], needed to deal with
+    // iterators that may invalidate referents upon destruction.
+    // Consider the temporary iterator in *(a + n)
+    template <class Iterator>
+    class operator_brackets_proxy
+    {
+        // Iterator is actually an iterator_facade, so we do not have to
+        // go through iterator_traits to access the traits.
+        typedef typename Iterator::reference  reference;
+        typedef typename Iterator::value_type value_type;
+
+     public:
+        operator_brackets_proxy(Iterator const& iter)
+          : m_iter(iter)
+        {}
+
+        operator reference() const
+        {
+            return *m_iter;
+        }
+
+        operator_brackets_proxy& operator=(value_type const& val)
+        {
+            *m_iter = val;
+            return *this;
+        }
+
+     private:
+        Iterator m_iter;
+    };
+
+    // A metafunction that determines whether operator[] must return a
+    // proxy, or whether it can simply return a copy of the value_type.
+    template <class ValueType, class Reference>
+    struct use_operator_brackets_proxy
+      : mpl::not_<
+            mpl::and_<
+                // Really we want an is_copy_constructible trait here,
+                // but is_POD will have to suffice in the meantime.
+                boost::is_POD<ValueType>
+              , iterator_writability_disabled<ValueType,Reference>
+            >
+        >
+    {};
+
+    template <class Iterator, class Value, class Reference>
+    struct operator_brackets_result
+    {
+        typedef typename mpl::if_<
+            use_operator_brackets_proxy<Value,Reference>
+          , operator_brackets_proxy<Iterator>
+          , Value
+        >::type type;
+    };
+
+    template <class Iterator>
+    operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::true_)
+    {
+        return operator_brackets_proxy<Iterator>(iter);
+    }
+
+    template <class Iterator>
+    typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_)
+    {
+      return *iter;
+    }
+
+    struct choose_difference_type
+    {
+        template <class I1, class I2>
+        struct apply
+          :
+# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+          iterator_difference<I1>
+# else
+          mpl::eval_if<
+              is_convertible<I2,I1>
+            , iterator_difference<I1>
+            , iterator_difference<I2>
+          >
+# endif
+        {};
+
+    };
+
+    template <
+        class Derived
+      , class Value
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+      , bool IsBidirectionalTraversal
+      , bool IsRandomAccessTraversal
+    >
+    class iterator_facade_base;
+
+  } // namespace detail
+
+
+  // Macros which describe the declarations of binary operators
+# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler)       \
+    template <                                                              \
+        class Derived1, class V1, class TC1, class Reference1, class Difference1 \
+      , class Derived2, class V2, class TC2, class Reference2, class Difference2 \
+    >                                                                       \
+    prefix typename mpl::apply2<result_type,Derived1,Derived2>::type \
+    operator op(                                                            \
+        iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs   \
+      , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
+# else
+#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler)   \
+    template <                                                          \
+        class Derived1, class V1, class TC1, class Reference1, class Difference1 \
+      , class Derived2, class V2, class TC2, class Reference2, class Difference2 \
+    >                                                                   \
+    prefix typename enabler<                                            \
+        Derived1, Derived2                                              \
+      , typename mpl::apply2<result_type,Derived1,Derived2>::type       \
+    >::type                                                             \
+    operator op(                                                        \
+        iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs   \
+      , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
+# endif
+
+#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)       \
+    BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable)
+
+#  define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(prefix, op, result_type)       \
+    BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable_and_random_access_traversal)
+
+#  define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args)              \
+    template <class Derived, class V, class TC, class R, class D>   \
+    prefix typename boost::iterators::enable_if<                    \
+        boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >,  \
+        Derived                                                     \
+    >::type operator+ args
+
+  //
+  // Helper class for granting access to the iterator core interface.
+  //
+  // The simple core interface is used by iterator_facade. The core
+  // interface of a user/library defined iterator type should not be made public
+  // so that it does not clutter the public interface. Instead iterator_core_access
+  // should be made friend so that iterator_facade can access the core
+  // interface through iterator_core_access.
+  //
+  class iterator_core_access
+  {
+# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+      // Tasteless as this may seem, making all members public allows member templates
+      // to work in the absence of member template friends.
+   public:
+# else
+
+      template <class I, class V, class TC, class R, class D> friend class iterator_facade;
+      template <class I, class V, class TC, class R, class D, bool IsBidirectionalTraversal, bool IsRandomAccessTraversal>
+      friend class detail::iterator_facade_base;
+
+#  define BOOST_ITERATOR_FACADE_RELATION(op)                                \
+      BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::iterators::detail::always_bool2);
+
+      BOOST_ITERATOR_FACADE_RELATION(==)
+      BOOST_ITERATOR_FACADE_RELATION(!=)
+
+#  undef BOOST_ITERATOR_FACADE_RELATION
+
+#  define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op)                                \
+      BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(friend,op, boost::iterators::detail::always_bool2);
+
+      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<)
+      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>)
+      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=)
+      BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=)
+
+#  undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION
+
+      BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(
+          friend, -, boost::iterators::detail::choose_difference_type)
+      ;
+
+      BOOST_ITERATOR_FACADE_PLUS_HEAD(
+          friend inline
+        , (iterator_facade<Derived, V, TC, R, D> const&
+        , typename Derived::difference_type)
+      )
+      ;
+
+      BOOST_ITERATOR_FACADE_PLUS_HEAD(
+          friend inline
+        , (typename Derived::difference_type
+        , iterator_facade<Derived, V, TC, R, D> const&)
+      )
+      ;
+
+# endif
+
+      template <class Facade>
+      static typename Facade::reference dereference(Facade const& f)
+      {
+          return f.dereference();
+      }
+
+      template <class Facade>
+      static void increment(Facade& f)
+      {
+          f.increment();
+      }
+
+      template <class Facade>
+      static void decrement(Facade& f)
+      {
+          f.decrement();
+      }
+
+      template <class Facade1, class Facade2>
+      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
+      {
+          return f1.equal(f2);
+      }
+
+      template <class Facade1, class Facade2>
+      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
+      {
+          return f2.equal(f1);
+      }
+
+      template <class Facade>
+      static void advance(Facade& f, typename Facade::difference_type n)
+      {
+          f.advance(n);
+      }
+
+      template <class Facade1, class Facade2>
+      static typename Facade1::difference_type distance_from(
+          Facade1 const& f1, Facade2 const& f2, mpl::true_)
+      {
+          return -f1.distance_to(f2);
+      }
+
+      template <class Facade1, class Facade2>
+      static typename Facade2::difference_type distance_from(
+          Facade1 const& f1, Facade2 const& f2, mpl::false_)
+      {
+          return f2.distance_to(f1);
+      }
+
+      //
+      // Curiously Recurring Template interface.
+      //
+      template <class I, class V, class TC, class R, class D>
+      static I& derived(iterator_facade<I,V,TC,R,D>& facade)
+      {
+          return *static_cast<I*>(&facade);
+      }
+
+      template <class I, class V, class TC, class R, class D>
+      static I const& derived(iterator_facade<I,V,TC,R,D> const& facade)
+      {
+          return *static_cast<I const*>(&facade);
+      }
+
+      // objects of this class are useless
+      BOOST_DELETED_FUNCTION(iterator_core_access())
+  };
+
+  namespace detail {
+
+    // Implementation for forward traversal iterators
+    template <
+        class Derived
+      , class Value
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+    >
+    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
+# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
+        : public boost::iterators::detail::iterator_facade_types<
+             Value, CategoryOrTraversal, Reference, Difference
+          >::base
+#  undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
+# endif
+    {
+    private:
+        typedef boost::iterators::detail::iterator_facade_types<
+            Value, CategoryOrTraversal, Reference, Difference
+        > associated_types;
+
+        typedef boost::iterators::detail::operator_arrow_dispatch<
+            Reference
+          , typename associated_types::pointer
+        > operator_arrow_dispatch_;
+
+    public:
+        typedef typename associated_types::value_type value_type;
+        typedef Reference reference;
+        typedef Difference difference_type;
+
+        typedef typename operator_arrow_dispatch_::result_type pointer;
+
+        typedef typename associated_types::iterator_category iterator_category;
+
+    public:
+        reference operator*() const
+        {
+            return iterator_core_access::dereference(this->derived());
+        }
+
+        pointer operator->() const
+        {
+            return operator_arrow_dispatch_::apply(*this->derived());
+        }
+
+        Derived& operator++()
+        {
+            iterator_core_access::increment(this->derived());
+            return this->derived();
+        }
+
+    protected:
+        //
+        // Curiously Recurring Template interface.
+        //
+        Derived& derived()
+        {
+            return *static_cast<Derived*>(this);
+        }
+
+        Derived const& derived() const
+        {
+            return *static_cast<Derived const*>(this);
+        }
+    };
+
+    // Implementation for bidirectional traversal iterators
+    template <
+        class Derived
+      , class Value
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+    >
+    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > :
+        public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
+    {
+    public:
+        Derived& operator--()
+        {
+            iterator_core_access::decrement(this->derived());
+            return this->derived();
+        }
+
+        Derived operator--(int)
+        {
+            Derived tmp(this->derived());
+            --*this;
+            return tmp;
+        }
+    };
+
+    // Implementation for random access traversal iterators
+    template <
+        class Derived
+      , class Value
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+    >
+    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, true > :
+        public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false >
+    {
+    private:
+        typedef iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > base_type;
+
+    public:
+        typedef typename base_type::reference reference;
+        typedef typename base_type::difference_type difference_type;
+
+    public:
+        typename boost::iterators::detail::operator_brackets_result<Derived, Value, reference>::type
+        operator[](difference_type n) const
+        {
+            typedef boost::iterators::detail::use_operator_brackets_proxy<Value, Reference> use_proxy;
+
+            return boost::iterators::detail::make_operator_brackets_result<Derived>(
+                this->derived() + n
+              , use_proxy()
+            );
+        }
+
+        Derived& operator+=(difference_type n)
+        {
+            iterator_core_access::advance(this->derived(), n);
+            return this->derived();
+        }
+
+        Derived& operator-=(difference_type n)
+        {
+            iterator_core_access::advance(this->derived(), -n);
+            return this->derived();
+        }
+
+        Derived operator-(difference_type x) const
+        {
+            Derived result(this->derived());
+            return result -= x;
+        }
+    };
+
+  } // namespace detail
+
+  //
+  // iterator_facade - use as a public base class for defining new
+  // standard-conforming iterators.
+  //
+  template <
+      class Derived             // The derived iterator type being constructed
+    , class Value
+    , class CategoryOrTraversal
+    , class Reference   = Value&
+    , class Difference  = std::ptrdiff_t
+  >
+  class iterator_facade :
+      public detail::iterator_facade_base<
+          Derived,
+          Value,
+          CategoryOrTraversal,
+          Reference,
+          Difference,
+          detail::is_traversal_at_least< CategoryOrTraversal, bidirectional_traversal_tag >::value,
+          detail::is_traversal_at_least< CategoryOrTraversal, random_access_traversal_tag >::value
+      >
+  {
+  protected:
+      // For use by derived classes
+      typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_;
+  };
+
+  template <class I, class V, class TC, class R, class D>
+  inline typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type
+  operator++(
+      iterator_facade<I,V,TC,R,D>& i
+    , int
+  )
+  {
+      typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type
+          tmp(*static_cast<I*>(&i));
+
+      ++i;
+
+      return tmp;
+  }
+
+
+  //
+  // Comparison operator implementation. The library supplied operators
+  // enables the user to provide fully interoperable constant/mutable
+  // iterator types. I.e. the library provides all operators
+  // for all mutable/constant iterator combinations.
+  //
+  // Note though that this kind of interoperability for constant/mutable
+  // iterators is not required by the standard for container iterators.
+  // All the standard asks for is a conversion mutable -> constant.
+  // Most standard library implementations nowadays provide fully interoperable
+  // iterator implementations, but there are still heavily used implementations
+  // that do not provide them. (Actually it's even worse, they do not provide
+  // them for only a few iterators.)
+  //
+  // ?? Maybe a BOOST_ITERATOR_NO_FULL_INTEROPERABILITY macro should
+  //    enable the user to turn off mixed type operators
+  //
+  // The library takes care to provide only the right operator overloads.
+  // I.e.
+  //
+  // bool operator==(Iterator,      Iterator);
+  // bool operator==(ConstIterator, Iterator);
+  // bool operator==(Iterator,      ConstIterator);
+  // bool operator==(ConstIterator, ConstIterator);
+  //
+  //   ...
+  //
+  // In order to do so it uses c++ idioms that are not yet widely supported
+  // by current compiler releases. The library is designed to degrade gracefully
+  // in the face of compiler deficiencies. In general compiler
+  // deficiencies result in less strict error checking and more obscure
+  // error messages, functionality is not affected.
+  //
+  // For full operation compiler support for "Substitution Failure Is Not An Error"
+  // (aka. enable_if) and boost::is_convertible is required.
+  //
+  // The following problems occur if support is lacking.
+  //
+  // Pseudo code
+  //
+  // ---------------
+  // AdaptorA<Iterator1> a1;
+  // AdaptorA<Iterator2> a2;
+  //
+  // // This will result in a no such overload error in full operation
+  // // If enable_if or is_convertible is not supported
+  // // The instantiation will fail with an error hopefully indicating that
+  // // there is no operator== for Iterator1, Iterator2
+  // // The same will happen if no enable_if is used to remove
+  // // false overloads from the templated conversion constructor
+  // // of AdaptorA.
+  //
+  // a1 == a2;
+  // ----------------
+  //
+  // AdaptorA<Iterator> a;
+  // AdaptorB<Iterator> b;
+  //
+  // // This will result in a no such overload error in full operation
+  // // If enable_if is not supported the static assert used
+  // // in the operator implementation will fail.
+  // // This will accidently work if is_convertible is not supported.
+  //
+  // a == b;
+  // ----------------
+  //
+
+# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+#  define BOOST_ITERATOR_CONVERTIBLE(a,b) mpl::true_()
+# else
+#  define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible<a,b>()
+# endif
+
+# define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, return_prefix, base_op) \
+  BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type)                   \
+  {                                                                             \
+      /* For those compilers that do not support enable_if */                   \
+      BOOST_STATIC_ASSERT((                                                     \
+          is_interoperable< Derived1, Derived2 >::value                         \
+      ));                                                                       \
+      return_prefix iterator_core_access::base_op(                              \
+          *static_cast<Derived1 const*>(&lhs)                                   \
+        , *static_cast<Derived2 const*>(&rhs)                                   \
+        , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1)                         \
+      );                                                                        \
+  }
+
+# define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \
+  BOOST_ITERATOR_FACADE_INTEROP(                                    \
+      op                                                            \
+    , boost::iterators::detail::always_bool2                                   \
+    , return_prefix                                                 \
+    , base_op                                                       \
+  )
+
+  BOOST_ITERATOR_FACADE_RELATION(==, return, equal)
+  BOOST_ITERATOR_FACADE_RELATION(!=, return !, equal)
+
+# undef BOOST_ITERATOR_FACADE_RELATION
+
+
+# define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(op, result_type, return_prefix, base_op) \
+  BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(inline, op, result_type)                   \
+  {                                                                             \
+      /* For those compilers that do not support enable_if */                   \
+      BOOST_STATIC_ASSERT((                                                     \
+          is_interoperable< Derived1, Derived2 >::value &&                      \
+          boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && \
+          boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value \
+      ));                                                                       \
+      return_prefix iterator_core_access::base_op(                              \
+          *static_cast<Derived1 const*>(&lhs)                                   \
+        , *static_cast<Derived2 const*>(&rhs)                                   \
+        , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1)                         \
+      );                                                                        \
+  }
+
+# define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op, return_prefix, base_op) \
+  BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(                                    \
+      op                                                            \
+    , boost::iterators::detail::always_bool2                                   \
+    , return_prefix                                                 \
+    , base_op                                                       \
+  )
+
+  BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<, return 0 >, distance_from)
+  BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>, return 0 <, distance_from)
+  BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=, return 0 >=, distance_from)
+  BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=, return 0 <=, distance_from)
+
+# undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION
+
+  // operator- requires an additional part in the static assertion
+  BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(
+      -
+    , boost::iterators::detail::choose_difference_type
+    , return
+    , distance_from
+  )
+
+# undef BOOST_ITERATOR_FACADE_INTEROP
+# undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS
+
+# define BOOST_ITERATOR_FACADE_PLUS(args)           \
+  BOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args)     \
+  {                                                 \
+      Derived tmp(static_cast<Derived const&>(i));  \
+      return tmp += n;                              \
+  }
+
+  BOOST_ITERATOR_FACADE_PLUS((
+      iterator_facade<Derived, V, TC, R, D> const& i
+    , typename Derived::difference_type n
+  ))
+
+  BOOST_ITERATOR_FACADE_PLUS((
+      typename Derived::difference_type n
+    , iterator_facade<Derived, V, TC, R, D> const& i
+  ))
+
+# undef BOOST_ITERATOR_FACADE_PLUS
+# undef BOOST_ITERATOR_FACADE_PLUS_HEAD
+
+# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD
+# undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD
+# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL
+
+} // namespace iterators
+
+using iterators::iterator_core_access;
+using iterators::iterator_facade;
+
+} // namespace boost
+
+#include <boost/iterator/detail/config_undef.hpp>
+
+#endif // BOOST_ITERATOR_FACADE_23022003THW_HPP
diff --git a/contrib/src/boost/iterator/iterator_traits.hpp b/contrib/src/boost/iterator/iterator_traits.hpp
index 9721a02..1a5f1e0 100644
--- a/contrib/src/boost/iterator/iterator_traits.hpp
+++ b/contrib/src/boost/iterator/iterator_traits.hpp
@@ -1,60 +1,60 @@
-// 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)

-#ifndef ITERATOR_TRAITS_DWA200347_HPP

-# define ITERATOR_TRAITS_DWA200347_HPP

-

-# include <boost/detail/iterator.hpp>

-# include <boost/detail/workaround.hpp>

-

-namespace boost {

-namespace iterators {

-

-// Macro for supporting old compilers, no longer needed but kept

-// for backwards compatibility (it was documented).

-#define BOOST_ITERATOR_CATEGORY iterator_category

-

-

-template <class Iterator>

-struct iterator_value

-{

-    typedef typename boost::detail::iterator_traits<Iterator>::value_type type;

-};

-

-template <class Iterator>

-struct iterator_reference

-{

-    typedef typename boost::detail::iterator_traits<Iterator>::reference type;

-};

-

-

-template <class Iterator>

-struct iterator_pointer

-{

-    typedef typename boost::detail::iterator_traits<Iterator>::pointer type;

-};

-

-template <class Iterator>

-struct iterator_difference

-{

-    typedef typename boost::detail::iterator_traits<Iterator>::difference_type type;

-};

-

-template <class Iterator>

-struct iterator_category

-{

-    typedef typename boost::detail::iterator_traits<Iterator>::iterator_category type;

-};

-

-} // namespace iterators

-

-using iterators::iterator_value;

-using iterators::iterator_reference;

-using iterators::iterator_pointer;

-using iterators::iterator_difference;

-using iterators::iterator_category;

-

-} // namespace boost

-

-#endif // ITERATOR_TRAITS_DWA200347_HPP

+// 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)
+#ifndef ITERATOR_TRAITS_DWA200347_HPP
+# define ITERATOR_TRAITS_DWA200347_HPP
+
+# include <boost/detail/iterator.hpp>
+# include <boost/detail/workaround.hpp>
+
+namespace boost {
+namespace iterators {
+
+// Macro for supporting old compilers, no longer needed but kept
+// for backwards compatibility (it was documented).
+#define BOOST_ITERATOR_CATEGORY iterator_category
+
+
+template <class Iterator>
+struct iterator_value
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::value_type type;
+};
+
+template <class Iterator>
+struct iterator_reference
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::reference type;
+};
+
+
+template <class Iterator>
+struct iterator_pointer
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::pointer type;
+};
+
+template <class Iterator>
+struct iterator_difference
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::difference_type type;
+};
+
+template <class Iterator>
+struct iterator_category
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::iterator_category type;
+};
+
+} // namespace iterators
+
+using iterators::iterator_value;
+using iterators::iterator_reference;
+using iterators::iterator_pointer;
+using iterators::iterator_difference;
+using iterators::iterator_category;
+
+} // namespace boost
+
+#endif // ITERATOR_TRAITS_DWA200347_HPP
diff --git a/contrib/src/boost/iterator/reverse_iterator.hpp b/contrib/src/boost/iterator/reverse_iterator.hpp
index f9aab8f..3bef39e 100644
--- a/contrib/src/boost/iterator/reverse_iterator.hpp
+++ b/contrib/src/boost/iterator/reverse_iterator.hpp
@@ -1,74 +1,74 @@
-// (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)

-#ifndef BOOST_REVERSE_ITERATOR_23022003THW_HPP

-#define BOOST_REVERSE_ITERATOR_23022003THW_HPP

-

-#include <boost/next_prior.hpp>

-#include <boost/iterator.hpp>

-#include <boost/iterator/iterator_adaptor.hpp>

-

-namespace boost {

-namespace iterators {

-

-  //

-  //

-  //

-  template <class Iterator>

-  class reverse_iterator

-      : public iterator_adaptor< reverse_iterator<Iterator>, Iterator >

-  {

-      typedef iterator_adaptor< reverse_iterator<Iterator>, Iterator > super_t;

-

-      friend class iterator_core_access;

-

-   public:

-      reverse_iterator() {}

-

-      explicit reverse_iterator(Iterator x)

-          : super_t(x) {}

-

-      template<class OtherIterator>

-      reverse_iterator(

-          reverse_iterator<OtherIterator> const& r

-          , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0

-          )

-          : super_t(r.base())

-      {}

-

-   private:

-      typename super_t::reference dereference() const { return *boost::prior(this->base()); }

-

-      void increment() { --this->base_reference(); }

-      void decrement() { ++this->base_reference(); }

-

-      void advance(typename super_t::difference_type n)

-      {

-          this->base_reference() += -n;

-      }

-

-      template <class OtherIterator>

-      typename super_t::difference_type

-      distance_to(reverse_iterator<OtherIterator> const& y) const

-      {

-          return this->base_reference() - y.base();

-      }

-  };

-

-  template <class BidirectionalIterator>

-  inline reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)

-  {

-      return reverse_iterator<BidirectionalIterator>(x);

-  }

-

-} // namespace iterators

-

-using iterators::reverse_iterator;

-using iterators::make_reverse_iterator;

-

-} // namespace boost

-

-#endif // BOOST_REVERSE_ITERATOR_23022003THW_HPP

+// (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)
+#ifndef BOOST_REVERSE_ITERATOR_23022003THW_HPP
+#define BOOST_REVERSE_ITERATOR_23022003THW_HPP
+
+#include <boost/next_prior.hpp>
+#include <boost/iterator.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+
+namespace boost {
+namespace iterators {
+
+  //
+  //
+  //
+  template <class Iterator>
+  class reverse_iterator
+      : public iterator_adaptor< reverse_iterator<Iterator>, Iterator >
+  {
+      typedef iterator_adaptor< reverse_iterator<Iterator>, Iterator > super_t;
+
+      friend class iterator_core_access;
+
+   public:
+      reverse_iterator() {}
+
+      explicit reverse_iterator(Iterator x)
+          : super_t(x) {}
+
+      template<class OtherIterator>
+      reverse_iterator(
+          reverse_iterator<OtherIterator> const& r
+          , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
+          )
+          : super_t(r.base())
+      {}
+
+   private:
+      typename super_t::reference dereference() const { return *boost::prior(this->base()); }
+
+      void increment() { --this->base_reference(); }
+      void decrement() { ++this->base_reference(); }
+
+      void advance(typename super_t::difference_type n)
+      {
+          this->base_reference() += -n;
+      }
+
+      template <class OtherIterator>
+      typename super_t::difference_type
+      distance_to(reverse_iterator<OtherIterator> const& y) const
+      {
+          return this->base_reference() - y.base();
+      }
+  };
+
+  template <class BidirectionalIterator>
+  inline reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
+  {
+      return reverse_iterator<BidirectionalIterator>(x);
+  }
+
+} // namespace iterators
+
+using iterators::reverse_iterator;
+using iterators::make_reverse_iterator;
+
+} // namespace boost
+
+#endif // BOOST_REVERSE_ITERATOR_23022003THW_HPP
diff --git a/contrib/src/boost/iterator/transform_iterator.hpp b/contrib/src/boost/iterator/transform_iterator.hpp
index f607ca5..851f16f 100644
--- a/contrib/src/boost/iterator/transform_iterator.hpp
+++ b/contrib/src/boost/iterator/transform_iterator.hpp
@@ -1,171 +1,171 @@
-// (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)

-#ifndef BOOST_TRANSFORM_ITERATOR_23022003THW_HPP

-#define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP

-

-#include <boost/iterator.hpp>

-#include <boost/iterator/detail/enable_if.hpp>

-#include <boost/iterator/iterator_adaptor.hpp>

-#include <boost/iterator/iterator_categories.hpp>

-#include <boost/mpl/not.hpp>

-#include <boost/mpl/bool.hpp>

-#include <boost/type_traits/function_traits.hpp>

-#include <boost/type_traits/is_const.hpp>

-#include <boost/type_traits/is_class.hpp>

-#include <boost/type_traits/is_function.hpp>

-#include <boost/type_traits/is_reference.hpp>

-#include <boost/type_traits/remove_const.hpp>

-#include <boost/type_traits/remove_reference.hpp>

-#include <boost/utility/result_of.hpp>

-

-

-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))

-# include <boost/type_traits/is_base_and_derived.hpp>

-

-#endif

-#include <boost/iterator/detail/config_def.hpp>

-

-

-namespace boost {

-namespace iterators {

-

-  template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default>

-  class transform_iterator;

-

-  namespace detail

-  {

-    // Compute the iterator_adaptor instantiation to be used for transform_iterator

-    template <class UnaryFunc, class Iterator, class Reference, class Value>

-    struct transform_iterator_base

-    {

-     private:

-        // By default, dereferencing the iterator yields the same as

-        // the function.

-        typedef typename ia_dflt_help<

-            Reference

-          , result_of<const UnaryFunc(typename std::iterator_traits<Iterator>::reference)>

-        >::type reference;

-

-        // To get the default for Value: remove any reference on the

-        // result type, but retain any constness to signal

-        // non-writability.  Note that if we adopt Thomas' suggestion

-        // to key non-writability *only* on the Reference argument,

-        // we'd need to strip constness here as well.

-        typedef typename ia_dflt_help<

-            Value

-          , remove_reference<reference>

-        >::type cv_value_type;

-

-     public:

-        typedef iterator_adaptor<

-            transform_iterator<UnaryFunc, Iterator, Reference, Value>

-          , Iterator

-          , cv_value_type

-          , use_default    // Leave the traversal category alone

-          , reference

-        > type;

-    };

-  }

-

-  template <class UnaryFunc, class Iterator, class Reference, class Value>

-  class transform_iterator

-    : public boost::iterators::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type

-  {

-    typedef typename

-    boost::iterators::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type

-    super_t;

-

-    friend class iterator_core_access;

-

-  public:

-    transform_iterator() { }

-

-    transform_iterator(Iterator const& x, UnaryFunc f)

-      : super_t(x), m_f(f) { }

-

-    explicit transform_iterator(Iterator const& x)

-      : super_t(x)

-    {

-        // Pro8 is a little too aggressive about instantiating the

-        // body of this function.

-#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))

-        // don't provide this constructor if UnaryFunc is a

-        // function pointer type, since it will be 0.  Too dangerous.

-        BOOST_STATIC_ASSERT(is_class<UnaryFunc>::value);

-#endif

-    }

-

-    template <

-        class OtherUnaryFunction

-      , class OtherIterator

-      , class OtherReference

-      , class OtherValue>

-    transform_iterator(

-         transform_iterator<OtherUnaryFunction, OtherIterator, OtherReference, OtherValue> const& t

-       , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0

-#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310)

-       , typename enable_if_convertible<OtherUnaryFunction, UnaryFunc>::type* = 0

-#endif

-    )

-      : super_t(t.base()), m_f(t.functor())

-   {}

-

-    UnaryFunc functor() const

-      { return m_f; }

-

-  private:

-    typename super_t::reference dereference() const

-    { return m_f(*this->base()); }

-

-    // Probably should be the initial base class so it can be

-    // optimized away via EBO if it is an empty class.

-    UnaryFunc m_f;

-  };

-

-  template <class UnaryFunc, class Iterator>

-  inline transform_iterator<UnaryFunc, Iterator>

-  make_transform_iterator(Iterator it, UnaryFunc fun)

-  {

-      return transform_iterator<UnaryFunc, Iterator>(it, fun);

-  }

-

-  // Version which allows explicit specification of the UnaryFunc

-  // type.

-  //

-  // This generator is not provided if UnaryFunc is a function

-  // pointer type, because it's too dangerous: the default-constructed

-  // function pointer in the iterator be 0, leading to a runtime

-  // crash.

-  template <class UnaryFunc, class Iterator>

-  inline typename iterators::enable_if<

-      is_class<UnaryFunc>   // We should probably find a cheaper test than is_class<>

-    , transform_iterator<UnaryFunc, Iterator>

-  >::type

-  make_transform_iterator(Iterator it)

-  {

-      return transform_iterator<UnaryFunc, Iterator>(it, UnaryFunc());

-  }

-

-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)

-  template <class Return, class Argument, class Iterator>

-  inline transform_iterator< Return (*)(Argument), Iterator, Return>

-  make_transform_iterator(Iterator it, Return (*fun)(Argument))

-  {

-    return transform_iterator<Return (*)(Argument), Iterator, Return>(it, fun);

-  }

-#endif

-

-} // namespace iterators

-

-using iterators::transform_iterator;

-using iterators::make_transform_iterator;

-

-} // namespace boost

-

-#include <boost/iterator/detail/config_undef.hpp>

-

-#endif // BOOST_TRANSFORM_ITERATOR_23022003THW_HPP

+// (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)
+#ifndef BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
+#define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
+
+#include <boost/iterator.hpp>
+#include <boost/iterator/detail/enable_if.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/function_traits.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/utility/result_of.hpp>
+
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
+# include <boost/type_traits/is_base_and_derived.hpp>
+
+#endif
+#include <boost/iterator/detail/config_def.hpp>
+
+
+namespace boost {
+namespace iterators {
+
+  template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default>
+  class transform_iterator;
+
+  namespace detail
+  {
+    // Compute the iterator_adaptor instantiation to be used for transform_iterator
+    template <class UnaryFunc, class Iterator, class Reference, class Value>
+    struct transform_iterator_base
+    {
+     private:
+        // By default, dereferencing the iterator yields the same as
+        // the function.
+        typedef typename ia_dflt_help<
+            Reference
+          , result_of<const UnaryFunc(typename std::iterator_traits<Iterator>::reference)>
+        >::type reference;
+
+        // To get the default for Value: remove any reference on the
+        // result type, but retain any constness to signal
+        // non-writability.  Note that if we adopt Thomas' suggestion
+        // to key non-writability *only* on the Reference argument,
+        // we'd need to strip constness here as well.
+        typedef typename ia_dflt_help<
+            Value
+          , remove_reference<reference>
+        >::type cv_value_type;
+
+     public:
+        typedef iterator_adaptor<
+            transform_iterator<UnaryFunc, Iterator, Reference, Value>
+          , Iterator
+          , cv_value_type
+          , use_default    // Leave the traversal category alone
+          , reference
+        > type;
+    };
+  }
+
+  template <class UnaryFunc, class Iterator, class Reference, class Value>
+  class transform_iterator
+    : public boost::iterators::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
+  {
+    typedef typename
+    boost::iterators::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
+    super_t;
+
+    friend class iterator_core_access;
+
+  public:
+    transform_iterator() { }
+
+    transform_iterator(Iterator const& x, UnaryFunc f)
+      : super_t(x), m_f(f) { }
+
+    explicit transform_iterator(Iterator const& x)
+      : super_t(x)
+    {
+        // Pro8 is a little too aggressive about instantiating the
+        // body of this function.
+#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+        // don't provide this constructor if UnaryFunc is a
+        // function pointer type, since it will be 0.  Too dangerous.
+        BOOST_STATIC_ASSERT(is_class<UnaryFunc>::value);
+#endif
+    }
+
+    template <
+        class OtherUnaryFunction
+      , class OtherIterator
+      , class OtherReference
+      , class OtherValue>
+    transform_iterator(
+         transform_iterator<OtherUnaryFunction, OtherIterator, OtherReference, OtherValue> const& t
+       , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
+#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+       , typename enable_if_convertible<OtherUnaryFunction, UnaryFunc>::type* = 0
+#endif
+    )
+      : super_t(t.base()), m_f(t.functor())
+   {}
+
+    UnaryFunc functor() const
+      { return m_f; }
+
+  private:
+    typename super_t::reference dereference() const
+    { return m_f(*this->base()); }
+
+    // Probably should be the initial base class so it can be
+    // optimized away via EBO if it is an empty class.
+    UnaryFunc m_f;
+  };
+
+  template <class UnaryFunc, class Iterator>
+  inline transform_iterator<UnaryFunc, Iterator>
+  make_transform_iterator(Iterator it, UnaryFunc fun)
+  {
+      return transform_iterator<UnaryFunc, Iterator>(it, fun);
+  }
+
+  // Version which allows explicit specification of the UnaryFunc
+  // type.
+  //
+  // This generator is not provided if UnaryFunc is a function
+  // pointer type, because it's too dangerous: the default-constructed
+  // function pointer in the iterator be 0, leading to a runtime
+  // crash.
+  template <class UnaryFunc, class Iterator>
+  inline typename iterators::enable_if<
+      is_class<UnaryFunc>   // We should probably find a cheaper test than is_class<>
+    , transform_iterator<UnaryFunc, Iterator>
+  >::type
+  make_transform_iterator(Iterator it)
+  {
+      return transform_iterator<UnaryFunc, Iterator>(it, UnaryFunc());
+  }
+
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+  template <class Return, class Argument, class Iterator>
+  inline transform_iterator< Return (*)(Argument), Iterator, Return>
+  make_transform_iterator(Iterator it, Return (*fun)(Argument))
+  {
+    return transform_iterator<Return (*)(Argument), Iterator, Return>(it, fun);
+  }
+#endif
+
+} // namespace iterators
+
+using iterators::transform_iterator;
+using iterators::make_transform_iterator;
+
+} // namespace boost
+
+#include <boost/iterator/detail/config_undef.hpp>
+
+#endif // BOOST_TRANSFORM_ITERATOR_23022003THW_HPP