Squashed 'third_party/boostorg/iterator/' content from commit b2adecb
Change-Id: I284a73816f9cc846742923879275b84c6e0c915c
git-subtree-dir: third_party/boostorg/iterator
git-subtree-split: b2adecb951af025698618f19a3c838bd314966dc
diff --git a/include/boost/function_output_iterator.hpp b/include/boost/function_output_iterator.hpp
new file mode 100644
index 0000000..15dbcb9
--- /dev/null
+++ b/include/boost/function_output_iterator.hpp
@@ -0,0 +1,14 @@
+// (C) Copyright Andrey Semashev 2017.
+// 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_FUNCTION_OUTPUT_ITERATOR_HPP
+#define BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
+
+// This is a deprecated header left for backward compatibility.
+// Use boost/iterator/function_output_iterator.hpp instead.
+
+#include <boost/iterator/function_output_iterator.hpp>
+
+#endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
diff --git a/include/boost/generator_iterator.hpp b/include/boost/generator_iterator.hpp
new file mode 100644
index 0000000..0fe1569
--- /dev/null
+++ b/include/boost/generator_iterator.hpp
@@ -0,0 +1,85 @@
+// (C) Copyright Jens Maurer 2001.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Revision History:
+
+// 15 Nov 2001 Jens Maurer
+// created.
+
+// See http://www.boost.org/libs/utility/iterator_adaptors.htm for documentation.
+
+#ifndef BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
+#define BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
+
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/ref.hpp>
+
+namespace boost {
+namespace iterators {
+
+template<class Generator>
+class generator_iterator
+ : public iterator_facade<
+ generator_iterator<Generator>
+ , typename Generator::result_type
+ , single_pass_traversal_tag
+ , typename Generator::result_type const&
+ >
+{
+ typedef iterator_facade<
+ generator_iterator<Generator>
+ , typename Generator::result_type
+ , single_pass_traversal_tag
+ , typename Generator::result_type const&
+ > super_t;
+
+ public:
+ generator_iterator() {}
+ generator_iterator(Generator* g) : m_g(g), m_value((*m_g)()) {}
+
+ void increment()
+ {
+ m_value = (*m_g)();
+ }
+
+ const typename Generator::result_type&
+ dereference() const
+ {
+ return m_value;
+ }
+
+ bool equal(generator_iterator const& y) const
+ {
+ return this->m_g == y.m_g && this->m_value == y.m_value;
+ }
+
+ private:
+ Generator* m_g;
+ typename Generator::result_type m_value;
+};
+
+template<class Generator>
+struct generator_iterator_generator
+{
+ typedef generator_iterator<Generator> type;
+};
+
+template <class Generator>
+inline generator_iterator<Generator>
+make_generator_iterator(Generator & gen)
+{
+ typedef generator_iterator<Generator> result_t;
+ return result_t(&gen);
+}
+
+} // namespace iterators
+
+using iterators::generator_iterator;
+using iterators::generator_iterator_generator;
+using iterators::make_generator_iterator;
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
diff --git a/include/boost/indirect_reference.hpp b/include/boost/indirect_reference.hpp
new file mode 100644
index 0000000..3279cd0
--- /dev/null
+++ b/include/boost/indirect_reference.hpp
@@ -0,0 +1,43 @@
+#ifndef INDIRECT_REFERENCE_DWA200415_HPP
+# define INDIRECT_REFERENCE_DWA200415_HPP
+
+//
+// Copyright David Abrahams 2004. Use, modification and distribution is
+// subject to the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// typename indirect_reference<P>::type provides the type of *p.
+//
+// http://www.boost.org/libs/iterator/doc/pointee.html
+//
+
+# include <boost/detail/is_incrementable.hpp>
+# include <boost/iterator/iterator_traits.hpp>
+# include <boost/type_traits/remove_cv.hpp>
+# include <boost/mpl/eval_if.hpp>
+# include <boost/pointee.hpp>
+
+namespace boost {
+
+namespace detail
+{
+ template <class P>
+ struct smart_ptr_reference
+ {
+ typedef typename boost::pointee<P>::type& type;
+ };
+}
+
+template <class P>
+struct indirect_reference
+ : mpl::eval_if<
+ detail::is_incrementable<P>
+ , iterator_reference<P>
+ , detail::smart_ptr_reference<P>
+ >
+{
+};
+
+} // namespace boost
+
+#endif // INDIRECT_REFERENCE_DWA200415_HPP
diff --git a/include/boost/iterator/advance.hpp b/include/boost/iterator/advance.hpp
new file mode 100644
index 0000000..6f81cdb
--- /dev/null
+++ b/include/boost/iterator/advance.hpp
@@ -0,0 +1,84 @@
+// Copyright (C) 2017 Michel Morin.
+//
+// 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_ADVANCE_HPP
+#define BOOST_ITERATOR_ADVANCE_HPP
+
+#include <boost/config.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+namespace boost {
+namespace iterators {
+
+ namespace detail {
+ template <typename InputIterator, typename Distance>
+ inline BOOST_CXX14_CONSTEXPR void
+ advance_impl(
+ InputIterator& it
+ , Distance n
+ , incrementable_traversal_tag
+ )
+ {
+ while (n > 0) {
+ ++it;
+ --n;
+ }
+ }
+
+ template <typename BidirectionalIterator, typename Distance>
+ inline BOOST_CXX14_CONSTEXPR void
+ advance_impl(
+ BidirectionalIterator& it
+ , Distance n
+ , bidirectional_traversal_tag
+ )
+ {
+ if (n >= 0) {
+ while (n > 0) {
+ ++it;
+ --n;
+ }
+ }
+ else {
+ while (n < 0) {
+ --it;
+ ++n;
+ }
+ }
+ }
+
+ template <typename RandomAccessIterator, typename Distance>
+ inline BOOST_CXX14_CONSTEXPR void
+ advance_impl(
+ RandomAccessIterator& it
+ , Distance n
+ , random_access_traversal_tag
+ )
+ {
+ it += n;
+ }
+ }
+
+ namespace advance_adl_barrier {
+ template <typename InputIterator, typename Distance>
+ inline BOOST_CXX14_CONSTEXPR void
+ advance(InputIterator& it, Distance n)
+ {
+ detail::advance_impl(
+ it, n, typename iterator_traversal<InputIterator>::type()
+ );
+ }
+ }
+
+ using namespace advance_adl_barrier;
+
+} // namespace iterators
+
+using iterators::advance;
+
+} // namespace boost
+
+#endif
diff --git a/include/boost/iterator/counting_iterator.hpp b/include/boost/iterator/counting_iterator.hpp
new file mode 100644
index 0000000..d90980e
--- /dev/null
+++ b/include/boost/iterator/counting_iterator.hpp
@@ -0,0 +1,220 @@
+// 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 COUNTING_ITERATOR_DWA200348_HPP
+# define COUNTING_ITERATOR_DWA200348_HPP
+
+# include <boost/iterator/iterator_adaptor.hpp>
+# include <boost/detail/numeric_traits.hpp>
+# include <boost/mpl/bool.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/mpl/identity.hpp>
+# include <boost/mpl/eval_if.hpp>
+
+namespace boost {
+namespace iterators {
+
+template <
+ class Incrementable
+ , class CategoryOrTraversal
+ , class Difference
+>
+class counting_iterator;
+
+namespace detail
+{
+ // Try to detect numeric types at compile time in ways compatible
+ // with the limitations of the compiler and library.
+ template <class T>
+ struct is_numeric_impl
+ {
+ // For a while, this wasn't true, but we rely on it below. This is a regression assert.
+ BOOST_STATIC_ASSERT(::boost::is_integral<char>::value);
+
+# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+
+ BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<T>::is_specialized);
+
+# else
+
+# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+ BOOST_STATIC_CONSTANT(
+ bool, value = (
+ boost::is_convertible<int,T>::value
+ && boost::is_convertible<T,int>::value
+ ));
+# else
+ BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
+# endif
+
+# endif
+ };
+
+ template <class T>
+ struct is_numeric
+ : mpl::bool_<(::boost::iterators::detail::is_numeric_impl<T>::value)>
+ {};
+
+# if defined(BOOST_HAS_LONG_LONG)
+ template <>
+ struct is_numeric< ::boost::long_long_type>
+ : mpl::true_ {};
+
+ template <>
+ struct is_numeric< ::boost::ulong_long_type>
+ : mpl::true_ {};
+# endif
+
+ // Some compilers fail to have a numeric_limits specialization
+ template <>
+ struct is_numeric<wchar_t>
+ : mpl::true_ {};
+
+ template <class T>
+ struct numeric_difference
+ {
+ typedef typename boost::detail::numeric_traits<T>::difference_type type;
+ };
+
+ BOOST_STATIC_ASSERT(is_numeric<int>::value);
+
+ template <class Incrementable, class CategoryOrTraversal, class Difference>
+ struct counting_iterator_base
+ {
+ typedef typename detail::ia_dflt_help<
+ CategoryOrTraversal
+ , mpl::eval_if<
+ is_numeric<Incrementable>
+ , mpl::identity<random_access_traversal_tag>
+ , iterator_traversal<Incrementable>
+ >
+ >::type traversal;
+
+ typedef typename detail::ia_dflt_help<
+ Difference
+ , mpl::eval_if<
+ is_numeric<Incrementable>
+ , numeric_difference<Incrementable>
+ , iterator_difference<Incrementable>
+ >
+ >::type difference;
+
+ typedef iterator_adaptor<
+ counting_iterator<Incrementable, CategoryOrTraversal, Difference> // self
+ , Incrementable // Base
+ , Incrementable // Value
+# ifndef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
+ const // MSVC won't strip this. Instead we enable Thomas'
+ // criterion (see boost/iterator/detail/facade_iterator_category.hpp)
+# endif
+ , traversal
+ , Incrementable const& // reference
+ , difference
+ > type;
+ };
+
+ // Template class distance_policy_select -- choose a policy for computing the
+ // distance between counting_iterators at compile-time based on whether or not
+ // the iterator wraps an integer or an iterator, using "poor man's partial
+ // specialization".
+
+ template <bool is_integer> struct distance_policy_select;
+
+ // A policy for wrapped iterators
+ template <class Difference, class Incrementable1, class Incrementable2>
+ struct iterator_distance
+ {
+ static Difference distance(Incrementable1 x, Incrementable2 y)
+ {
+ return y - x;
+ }
+ };
+
+ // A policy for wrapped numbers
+ template <class Difference, class Incrementable1, class Incrementable2>
+ struct number_distance
+ {
+ static Difference distance(Incrementable1 x, Incrementable2 y)
+ {
+ return boost::detail::numeric_distance(x, y);
+ }
+ };
+}
+
+template <
+ class Incrementable
+ , class CategoryOrTraversal = use_default
+ , class Difference = use_default
+>
+class counting_iterator
+ : public detail::counting_iterator_base<
+ Incrementable, CategoryOrTraversal, Difference
+ >::type
+{
+ typedef typename detail::counting_iterator_base<
+ Incrementable, CategoryOrTraversal, Difference
+ >::type super_t;
+
+ friend class iterator_core_access;
+
+ public:
+ typedef typename super_t::difference_type difference_type;
+
+ counting_iterator() { }
+
+ counting_iterator(counting_iterator const& rhs) : super_t(rhs.base()) {}
+
+ counting_iterator(Incrementable x)
+ : super_t(x)
+ {
+ }
+
+# if 0
+ template<class OtherIncrementable>
+ counting_iterator(
+ counting_iterator<OtherIncrementable, CategoryOrTraversal, Difference> const& t
+ , typename enable_if_convertible<OtherIncrementable, Incrementable>::type* = 0
+ )
+ : super_t(t.base())
+ {}
+# endif
+
+ private:
+
+ typename super_t::reference dereference() const
+ {
+ return this->base_reference();
+ }
+
+ template <class OtherIncrementable>
+ difference_type
+ distance_to(counting_iterator<OtherIncrementable, CategoryOrTraversal, Difference> const& y) const
+ {
+ typedef typename mpl::if_<
+ detail::is_numeric<Incrementable>
+ , detail::number_distance<difference_type, Incrementable, OtherIncrementable>
+ , detail::iterator_distance<difference_type, Incrementable, OtherIncrementable>
+ >::type d;
+
+ return d::distance(this->base(), y.base());
+ }
+};
+
+// Manufacture a counting iterator for an arbitrary incrementable type
+template <class Incrementable>
+inline counting_iterator<Incrementable>
+make_counting_iterator(Incrementable x)
+{
+ typedef counting_iterator<Incrementable> result_t;
+ return result_t(x);
+}
+
+} // namespace iterators
+
+using iterators::counting_iterator;
+using iterators::make_counting_iterator;
+
+} // namespace boost
+
+#endif // COUNTING_ITERATOR_DWA200348_HPP
diff --git a/include/boost/iterator/detail/any_conversion_eater.hpp b/include/boost/iterator/detail/any_conversion_eater.hpp
new file mode 100644
index 0000000..429421f
--- /dev/null
+++ b/include/boost/iterator/detail/any_conversion_eater.hpp
@@ -0,0 +1,21 @@
+// 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 ANY_CONVERSION_EATER_DWA20031117_HPP
+# define ANY_CONVERSION_EATER_DWA20031117_HPP
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+// This type can be used in traits to "eat" up the one user-defined
+// implicit conversion allowed.
+struct any_conversion_eater
+{
+ template <class T>
+ any_conversion_eater(T const&);
+};
+
+}}} // namespace boost::iterators::detail
+
+#endif // ANY_CONVERSION_EATER_DWA20031117_HPP
diff --git a/include/boost/iterator/detail/config_def.hpp b/include/boost/iterator/detail/config_def.hpp
new file mode 100644
index 0000000..117e75a
--- /dev/null
+++ b/include/boost/iterator/detail/config_def.hpp
@@ -0,0 +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
diff --git a/include/boost/iterator/detail/config_undef.hpp b/include/boost/iterator/detail/config_undef.hpp
new file mode 100644
index 0000000..bf1b8d7
--- /dev/null
+++ b/include/boost/iterator/detail/config_undef.hpp
@@ -0,0 +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
diff --git a/include/boost/iterator/detail/enable_if.hpp b/include/boost/iterator/detail/enable_if.hpp
new file mode 100644
index 0000000..071f5fe
--- /dev/null
+++ b/include/boost/iterator/detail/enable_if.hpp
@@ -0,0 +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
diff --git a/include/boost/iterator/detail/facade_iterator_category.hpp b/include/boost/iterator/detail/facade_iterator_category.hpp
new file mode 100644
index 0000000..67fdf44
--- /dev/null
+++ b/include/boost/iterator/detail/facade_iterator_category.hpp
@@ -0,0 +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
diff --git a/include/boost/iterator/detail/minimum_category.hpp b/include/boost/iterator/detail/minimum_category.hpp
new file mode 100644
index 0000000..748c0d3
--- /dev/null
+++ b/include/boost/iterator/detail/minimum_category.hpp
@@ -0,0 +1,19 @@
+// 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 MINIMUM_CATEGORY_DWA20031119_HPP
+# define MINIMUM_CATEGORY_DWA20031119_HPP
+
+# include <boost/iterator/minimum_category.hpp>
+
+namespace boost {
+
+// This import below (as well as the whole header) is for backward compatibility
+// with boost/token_iterator.hpp. It should be removed as soon as that header is fixed.
+namespace detail {
+using iterators::minimum_category;
+} // namespace detail
+
+} // namespace boost
+
+#endif // MINIMUM_CATEGORY_DWA20031119_HPP
diff --git a/include/boost/iterator/distance.hpp b/include/boost/iterator/distance.hpp
new file mode 100644
index 0000000..8cf3f15
--- /dev/null
+++ b/include/boost/iterator/distance.hpp
@@ -0,0 +1,65 @@
+// Copyright (C) 2017 Michel Morin.
+//
+// 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_DISTANCE_HPP
+#define BOOST_ITERATOR_DISTANCE_HPP
+
+#include <boost/config.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost {
+namespace iterators {
+
+ namespace detail {
+ template <typename SinglePassIterator>
+ inline BOOST_CXX14_CONSTEXPR typename iterator_difference<SinglePassIterator>::type
+ distance_impl(
+ SinglePassIterator first
+ , SinglePassIterator last
+ , single_pass_traversal_tag
+ )
+ {
+ typename iterator_difference<SinglePassIterator>::type n = 0;
+ while (first != last) {
+ ++first;
+ ++n;
+ }
+ return n;
+ }
+
+ template <typename RandomAccessIterator>
+ inline BOOST_CXX14_CONSTEXPR typename iterator_difference<RandomAccessIterator>::type
+ distance_impl(
+ RandomAccessIterator first
+ , RandomAccessIterator last
+ , random_access_traversal_tag
+ )
+ {
+ return last - first;
+ }
+ }
+
+ namespace distance_adl_barrier {
+ template <typename SinglePassIterator>
+ inline BOOST_CXX14_CONSTEXPR typename iterator_difference<SinglePassIterator>::type
+ distance(SinglePassIterator first, SinglePassIterator last)
+ {
+ return detail::distance_impl(
+ first, last, typename iterator_traversal<SinglePassIterator>::type()
+ );
+ }
+ }
+
+ using namespace distance_adl_barrier;
+
+} // namespace iterators
+
+using iterators::distance;
+
+} // namespace boost
+
+#endif
diff --git a/include/boost/iterator/filter_iterator.hpp b/include/boost/iterator/filter_iterator.hpp
new file mode 100644
index 0000000..b87c02b
--- /dev/null
+++ b/include/boost/iterator/filter_iterator.hpp
@@ -0,0 +1,136 @@
+// (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_FILTER_ITERATOR_23022003THW_HPP
+#define BOOST_FILTER_ITERATOR_23022003THW_HPP
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+#include <boost/type_traits/is_class.hpp>
+#include <boost/static_assert.hpp>
+
+namespace boost {
+namespace iterators {
+
+ template <class Predicate, class Iterator>
+ class filter_iterator;
+
+ namespace detail
+ {
+ template <class Predicate, class Iterator>
+ struct filter_iterator_base
+ {
+ typedef iterator_adaptor<
+ filter_iterator<Predicate, Iterator>
+ , Iterator
+ , use_default
+ , typename mpl::if_<
+ is_convertible<
+ typename iterator_traversal<Iterator>::type
+ , random_access_traversal_tag
+ >
+ , bidirectional_traversal_tag
+ , use_default
+ >::type
+ > type;
+ };
+ }
+
+ template <class Predicate, class Iterator>
+ class filter_iterator
+ : public detail::filter_iterator_base<Predicate, Iterator>::type
+ {
+ typedef typename detail::filter_iterator_base<
+ Predicate, Iterator
+ >::type super_t;
+
+ friend class iterator_core_access;
+
+ public:
+ filter_iterator() { }
+
+ filter_iterator(Predicate f, Iterator x, Iterator end_ = Iterator())
+ : super_t(x), m_predicate(f), m_end(end_)
+ {
+ satisfy_predicate();
+ }
+
+ filter_iterator(Iterator x, Iterator end_ = Iterator())
+ : super_t(x), m_predicate(), m_end(end_)
+ {
+ // Pro8 is a little too aggressive about instantiating the
+ // body of this function.
+#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+ // Don't allow use of this constructor if Predicate is a
+ // function pointer type, since it will be 0.
+ BOOST_STATIC_ASSERT(is_class<Predicate>::value);
+#endif
+ satisfy_predicate();
+ }
+
+ template<class OtherIterator>
+ filter_iterator(
+ filter_iterator<Predicate, OtherIterator> const& t
+ , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
+ )
+ : super_t(t.base()), m_predicate(t.predicate()), m_end(t.end()) {}
+
+ Predicate predicate() const { return m_predicate; }
+
+ Iterator end() const { return m_end; }
+
+ private:
+ void increment()
+ {
+ ++(this->base_reference());
+ satisfy_predicate();
+ }
+
+ void decrement()
+ {
+ while(!this->m_predicate(*--(this->base_reference()))){};
+ }
+
+ void satisfy_predicate()
+ {
+ while (this->base() != this->m_end && !this->m_predicate(*this->base()))
+ ++(this->base_reference());
+ }
+
+ // Probably should be the initial base class so it can be
+ // optimized away via EBO if it is an empty class.
+ Predicate m_predicate;
+ Iterator m_end;
+ };
+
+ template <class Predicate, class Iterator>
+ inline filter_iterator<Predicate,Iterator>
+ make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator())
+ {
+ return filter_iterator<Predicate,Iterator>(f,x,end);
+ }
+
+ template <class Predicate, class Iterator>
+ inline filter_iterator<Predicate,Iterator>
+ make_filter_iterator(
+ typename iterators::enable_if<
+ is_class<Predicate>
+ , Iterator
+ >::type x
+ , Iterator end = Iterator())
+ {
+ return filter_iterator<Predicate,Iterator>(x,end);
+ }
+
+} // namespace iterators
+
+using iterators::filter_iterator;
+using iterators::make_filter_iterator;
+
+} // namespace boost
+
+#endif // BOOST_FILTER_ITERATOR_23022003THW_HPP
diff --git a/include/boost/iterator/function_input_iterator.hpp b/include/boost/iterator/function_input_iterator.hpp
new file mode 100644
index 0000000..caa6272
--- /dev/null
+++ b/include/boost/iterator/function_input_iterator.hpp
@@ -0,0 +1,172 @@
+// Copyright 2009 (C) Dean Michael Berris <me@deanberris.com>
+// Copyright 2012 (C) Google, Inc.
+// Copyright 2012 (C) Jeffrey Lee Hellrung, Jr.
+// 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_FUNCTION_INPUT_ITERATOR
+#define BOOST_FUNCTION_INPUT_ITERATOR
+
+#include <boost/config.hpp>
+#include <boost/assert.hpp>
+#include <boost/core/addressof.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/function_types/is_function_pointer.hpp>
+#include <boost/function_types/result_type.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/none.hpp>
+#include <boost/optional/optional.hpp>
+#include <boost/utility/result_of.hpp>
+
+#ifdef BOOST_RESULT_OF_USE_TR1
+#include <boost/type_traits/is_function.hpp>
+#endif
+
+namespace boost {
+
+namespace iterators {
+
+ namespace impl {
+
+ // Computes the return type of an lvalue-call with an empty argument,
+ // i.e. decltype(declval<F&>()()). F should be a nullary lvalue-callable
+ // or function.
+ template <class F>
+ struct result_of_nullary_lvalue_call
+ {
+ typedef typename result_of<
+#ifdef BOOST_RESULT_OF_USE_TR1
+ typename mpl::if_<is_function<F>, F&, F>::type()
+#else
+ F&()
+#endif
+ >::type type;
+ };
+
+ template <class Function, class Input>
+ class function_input_iterator
+ : public iterator_facade<
+ function_input_iterator<Function, Input>,
+ typename result_of_nullary_lvalue_call<Function>::type,
+ single_pass_traversal_tag,
+ typename result_of_nullary_lvalue_call<Function>::type const &
+ >
+ {
+ public:
+ function_input_iterator() {}
+ function_input_iterator(Function & f_, Input state_ = Input())
+ : f(boost::addressof(f_)), state(state_) {}
+
+ void increment() {
+ if(value)
+ value = none;
+ else
+ (*f)();
+ ++state;
+ }
+
+ typename result_of_nullary_lvalue_call<Function>::type const &
+ dereference() const {
+ return (value ? value : value = (*f)()).get();
+ }
+
+ bool equal(function_input_iterator const & other) const {
+ return f == other.f && state == other.state;
+ }
+
+ private:
+ Function * f;
+ Input state;
+ mutable optional<typename result_of_nullary_lvalue_call<Function>::type> value;
+ };
+
+ template <class Function, class Input>
+ class function_pointer_input_iterator
+ : public iterator_facade<
+ function_pointer_input_iterator<Function, Input>,
+ typename function_types::result_type<Function>::type,
+ single_pass_traversal_tag,
+ typename function_types::result_type<Function>::type const &
+ >
+ {
+ public:
+ function_pointer_input_iterator() {}
+ function_pointer_input_iterator(Function &f_, Input state_ = Input())
+ : f(f_), state(state_) {}
+
+ void increment() {
+ if(value)
+ value = none;
+ else
+ (*f)();
+ ++state;
+ }
+
+ typename function_types::result_type<Function>::type const &
+ dereference() const {
+ return (value ? value : value = (*f)()).get();
+ }
+
+ bool equal(function_pointer_input_iterator const & other) const {
+ return f == other.f && state == other.state;
+ }
+
+ private:
+ Function f;
+ Input state;
+ mutable optional<typename function_types::result_type<Function>::type> value;
+ };
+
+ } // namespace impl
+
+ template <class Function, class Input>
+ class function_input_iterator
+ : public mpl::if_<
+ function_types::is_function_pointer<Function>,
+ impl::function_pointer_input_iterator<Function,Input>,
+ impl::function_input_iterator<Function,Input>
+ >::type
+ {
+ typedef typename mpl::if_<
+ function_types::is_function_pointer<Function>,
+ impl::function_pointer_input_iterator<Function,Input>,
+ impl::function_input_iterator<Function,Input>
+ >::type base_type;
+ public:
+ function_input_iterator(Function & f, Input i)
+ : base_type(f, i) {}
+ };
+
+ template <class Function, class Input>
+ inline function_input_iterator<Function, Input>
+ make_function_input_iterator(Function & f, Input state) {
+ typedef function_input_iterator<Function, Input> result_t;
+ return result_t(f, state);
+ }
+
+ template <class Function, class Input>
+ inline function_input_iterator<Function*, Input>
+ make_function_input_iterator(Function * f, Input state) {
+ typedef function_input_iterator<Function*, Input> result_t;
+ return result_t(f, state);
+ }
+
+ struct infinite {
+ infinite & operator++() { return *this; }
+ infinite & operator++(int) { return *this; }
+ bool operator==(infinite &) const { return false; };
+ bool operator==(infinite const &) const { return false; };
+ };
+
+} // namespace iterators
+
+using iterators::function_input_iterator;
+using iterators::make_function_input_iterator;
+using iterators::infinite;
+
+} // namespace boost
+
+#endif
+
diff --git a/include/boost/iterator/function_output_iterator.hpp b/include/boost/iterator/function_output_iterator.hpp
new file mode 100644
index 0000000..51fe835
--- /dev/null
+++ b/include/boost/iterator/function_output_iterator.hpp
@@ -0,0 +1,62 @@
+// (C) Copyright Jeremy Siek 2001.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Revision History:
+
+// 27 Feb 2001 Jeremy Siek
+// Initial checkin.
+
+#ifndef BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP
+#define BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP
+
+#include <iterator>
+
+namespace boost {
+namespace iterators {
+
+ template <class UnaryFunction>
+ class function_output_iterator {
+ typedef function_output_iterator self;
+ public:
+ typedef std::output_iterator_tag iterator_category;
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
+
+ explicit function_output_iterator() {}
+
+ explicit function_output_iterator(const UnaryFunction& f)
+ : m_f(f) {}
+
+ struct output_proxy {
+ output_proxy(UnaryFunction& f) : m_f(f) { }
+ template <class T> output_proxy& operator=(const T& value) {
+ m_f(value);
+ return *this;
+ }
+ UnaryFunction& m_f;
+ };
+ output_proxy operator*() { return output_proxy(m_f); }
+ self& operator++() { return *this; }
+ self& operator++(int) { return *this; }
+ private:
+ UnaryFunction m_f;
+ };
+
+ template <class UnaryFunction>
+ inline function_output_iterator<UnaryFunction>
+ make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) {
+ return function_output_iterator<UnaryFunction>(f);
+ }
+
+} // namespace iterators
+
+using iterators::function_output_iterator;
+using iterators::make_function_output_iterator;
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP
diff --git a/include/boost/iterator/indirect_iterator.hpp b/include/boost/iterator/indirect_iterator.hpp
new file mode 100644
index 0000000..7449d62
--- /dev/null
+++ b/include/boost/iterator/indirect_iterator.hpp
@@ -0,0 +1,145 @@
+// (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_INDIRECT_ITERATOR_23022003THW_HPP
+#define BOOST_INDIRECT_ITERATOR_23022003THW_HPP
+
+#include <boost/iterator/iterator_adaptor.hpp>
+
+#include <boost/pointee.hpp>
+#include <boost/indirect_reference.hpp>
+
+#include <boost/detail/indirect_traits.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/add_reference.hpp>
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/has_xxx.hpp>
+
+#include <iterator>
+
+#ifdef BOOST_MPL_CFG_NO_HAS_XXX
+# include <boost/shared_ptr.hpp>
+# include <boost/scoped_ptr.hpp>
+# include <boost/mpl/bool.hpp>
+# include <memory>
+#endif
+
+#include <boost/iterator/detail/config_def.hpp> // must be last #include
+
+namespace boost {
+namespace iterators {
+
+ template <class Iter, class Value, class Category, class Reference, class Difference>
+ class indirect_iterator;
+
+ namespace detail
+ {
+ template <class Iter, class Value, class Category, class Reference, class Difference>
+ struct indirect_base
+ {
+ typedef typename std::iterator_traits<Iter>::value_type dereferenceable;
+
+ typedef iterator_adaptor<
+ indirect_iterator<Iter, Value, Category, Reference, Difference>
+ , Iter
+ , typename ia_dflt_help<
+ Value, pointee<dereferenceable>
+ >::type
+ , Category
+ , typename ia_dflt_help<
+ Reference
+ , mpl::eval_if<
+ is_same<Value,use_default>
+ , indirect_reference<dereferenceable>
+ , add_reference<Value>
+ >
+ >::type
+ , Difference
+ > type;
+ };
+
+ template <>
+ struct indirect_base<int, int, int, int, int> {};
+ } // namespace detail
+
+
+ template <
+ class Iterator
+ , class Value = use_default
+ , class Category = use_default
+ , class Reference = use_default
+ , class Difference = use_default
+ >
+ class indirect_iterator
+ : public detail::indirect_base<
+ Iterator, Value, Category, Reference, Difference
+ >::type
+ {
+ typedef typename detail::indirect_base<
+ Iterator, Value, Category, Reference, Difference
+ >::type super_t;
+
+ friend class iterator_core_access;
+
+ public:
+ indirect_iterator() {}
+
+ indirect_iterator(Iterator iter)
+ : super_t(iter) {}
+
+ template <
+ class Iterator2, class Value2, class Category2
+ , class Reference2, class Difference2
+ >
+ indirect_iterator(
+ indirect_iterator<
+ Iterator2, Value2, Category2, Reference2, Difference2
+ > const& y
+ , typename enable_if_convertible<Iterator2, Iterator>::type* = 0
+ )
+ : super_t(y.base())
+ {}
+
+ private:
+ typename super_t::reference dereference() const
+ {
+# if BOOST_WORKAROUND(__BORLANDC__, < 0x5A0 )
+ return const_cast<super_t::reference>(**this->base());
+# else
+ return **this->base();
+# endif
+ }
+ };
+
+ template <class Iter>
+ inline
+ indirect_iterator<Iter> make_indirect_iterator(Iter x)
+ {
+ return indirect_iterator<Iter>(x);
+ }
+
+ template <class Traits, class Iter>
+ inline
+ indirect_iterator<Iter,Traits> make_indirect_iterator(Iter x, Traits* = 0)
+ {
+ return indirect_iterator<Iter, Traits>(x);
+ }
+
+} // namespace iterators
+
+using iterators::indirect_iterator;
+using iterators::make_indirect_iterator;
+
+} // namespace boost
+
+#include <boost/iterator/detail/config_undef.hpp>
+
+#endif // BOOST_INDIRECT_ITERATOR_23022003THW_HPP
diff --git a/include/boost/iterator/interoperable.hpp b/include/boost/iterator/interoperable.hpp
new file mode 100644
index 0000000..6f3c872
--- /dev/null
+++ b/include/boost/iterator/interoperable.hpp
@@ -0,0 +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
diff --git a/include/boost/iterator/is_lvalue_iterator.hpp b/include/boost/iterator/is_lvalue_iterator.hpp
new file mode 100644
index 0000000..46f0483
--- /dev/null
+++ b/include/boost/iterator/is_lvalue_iterator.hpp
@@ -0,0 +1,164 @@
+// 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 IS_LVALUE_ITERATOR_DWA2003112_HPP
+# define IS_LVALUE_ITERATOR_DWA2003112_HPP
+
+#include <boost/detail/workaround.hpp>
+
+#include <boost/type_traits/add_lvalue_reference.hpp>
+#include <boost/iterator/detail/any_conversion_eater.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <iterator>
+
+// should be the last #includes
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/iterator/detail/config_def.hpp>
+
+#ifndef BOOST_NO_IS_CONVERTIBLE
+
+namespace boost {
+
+namespace iterators {
+
+namespace detail
+{
+#ifndef BOOST_NO_LVALUE_RETURN_DETECTION
+ // Calling lvalue_preserver( <expression>, 0 ) returns a reference
+ // to the expression's result if <expression> is an lvalue, or
+ // not_an_lvalue() otherwise.
+ struct not_an_lvalue {};
+
+ template <class T>
+ T& lvalue_preserver(T&, int);
+
+ template <class U>
+ not_an_lvalue lvalue_preserver(U const&, ...);
+
+# define BOOST_LVALUE_PRESERVER(expr) detail::lvalue_preserver(expr,0)
+
+#else
+
+# define BOOST_LVALUE_PRESERVER(expr) expr
+
+#endif
+
+ // Guts of is_lvalue_iterator. Value is the iterator's value_type
+ // and the result is computed in the nested rebind template.
+ template <class Value>
+ struct is_lvalue_iterator_impl
+ {
+ // Eat implicit conversions so we don't report true for things
+ // convertible to Value const&
+ struct conversion_eater
+ {
+ conversion_eater(typename add_lvalue_reference<Value>::type);
+ };
+
+ static char tester(conversion_eater, int);
+ static char (& tester(any_conversion_eater, ...) )[2];
+
+ template <class It>
+ struct rebind
+ {
+ static It& x;
+
+ BOOST_STATIC_CONSTANT(
+ bool
+ , value = (
+ sizeof(
+ is_lvalue_iterator_impl<Value>::tester(
+ BOOST_LVALUE_PRESERVER(*x), 0
+ )
+ ) == 1
+ )
+ );
+ };
+ };
+
+#undef BOOST_LVALUE_PRESERVER
+
+ //
+ // void specializations to handle std input and output iterators
+ //
+ template <>
+ struct is_lvalue_iterator_impl<void>
+ {
+ template <class It>
+ struct rebind : boost::mpl::false_
+ {};
+ };
+
+#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
+ template <>
+ struct is_lvalue_iterator_impl<const void>
+ {
+ template <class It>
+ struct rebind : boost::mpl::false_
+ {};
+ };
+
+ template <>
+ struct is_lvalue_iterator_impl<volatile void>
+ {
+ template <class It>
+ struct rebind : boost::mpl::false_
+ {};
+ };
+
+ template <>
+ struct is_lvalue_iterator_impl<const volatile void>
+ {
+ template <class It>
+ struct rebind : boost::mpl::false_
+ {};
+ };
+#endif
+
+ //
+ // This level of dispatching is required for Borland. We might save
+ // an instantiation by removing it for others.
+ //
+ template <class It>
+ struct is_readable_lvalue_iterator_impl
+ : is_lvalue_iterator_impl<
+ BOOST_DEDUCED_TYPENAME std::iterator_traits<It>::value_type const
+ >::template rebind<It>
+ {};
+
+ template <class It>
+ struct is_non_const_lvalue_iterator_impl
+ : is_lvalue_iterator_impl<
+ BOOST_DEDUCED_TYPENAME std::iterator_traits<It>::value_type
+ >::template rebind<It>
+ {};
+} // namespace detail
+
+template< typename T > struct is_lvalue_iterator
+: public ::boost::integral_constant<bool,::boost::iterators::detail::is_readable_lvalue_iterator_impl<T>::value>
+{
+public:
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_lvalue_iterator,(T))
+};
+
+template< typename T > struct is_non_const_lvalue_iterator
+: public ::boost::integral_constant<bool,::boost::iterators::detail::is_non_const_lvalue_iterator_impl<T>::value>
+{
+public:
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_non_const_lvalue_iterator,(T))
+};
+
+} // namespace iterators
+
+using iterators::is_lvalue_iterator;
+using iterators::is_non_const_lvalue_iterator;
+
+} // namespace boost
+
+#endif
+
+#include <boost/iterator/detail/config_undef.hpp>
+
+#endif // IS_LVALUE_ITERATOR_DWA2003112_HPP
diff --git a/include/boost/iterator/is_readable_iterator.hpp b/include/boost/iterator/is_readable_iterator.hpp
new file mode 100644
index 0000000..26827c4
--- /dev/null
+++ b/include/boost/iterator/is_readable_iterator.hpp
@@ -0,0 +1,119 @@
+// 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 IS_READABLE_ITERATOR_DWA2003112_HPP
+# define IS_READABLE_ITERATOR_DWA2003112_HPP
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+#include <boost/type_traits/add_lvalue_reference.hpp>
+
+#include <boost/iterator/detail/any_conversion_eater.hpp>
+
+#include <iterator>
+
+// should be the last #include
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/iterator/detail/config_def.hpp>
+
+#ifndef BOOST_NO_IS_CONVERTIBLE
+
+namespace boost {
+
+namespace iterators {
+
+namespace detail
+{
+ // Guts of is_readable_iterator. Value is the iterator's value_type
+ // and the result is computed in the nested rebind template.
+ template <class Value>
+ struct is_readable_iterator_impl
+ {
+ static char tester(typename add_lvalue_reference<Value>::type, int);
+ static char (& tester(any_conversion_eater, ...) )[2];
+
+ template <class It>
+ struct rebind
+ {
+ static It& x;
+
+ BOOST_STATIC_CONSTANT(
+ bool
+ , value = (
+ sizeof(
+ is_readable_iterator_impl<Value>::tester(*x, 1)
+ ) == 1
+ )
+ );
+ };
+ };
+
+#undef BOOST_READABLE_PRESERVER
+
+ //
+ // void specializations to handle std input and output iterators
+ //
+ template <>
+ struct is_readable_iterator_impl<void>
+ {
+ template <class It>
+ struct rebind : boost::mpl::false_
+ {};
+ };
+
+#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
+ template <>
+ struct is_readable_iterator_impl<const void>
+ {
+ template <class It>
+ struct rebind : boost::mpl::false_
+ {};
+ };
+
+ template <>
+ struct is_readable_iterator_impl<volatile void>
+ {
+ template <class It>
+ struct rebind : boost::mpl::false_
+ {};
+ };
+
+ template <>
+ struct is_readable_iterator_impl<const volatile void>
+ {
+ template <class It>
+ struct rebind : boost::mpl::false_
+ {};
+ };
+#endif
+
+ //
+ // This level of dispatching is required for Borland. We might save
+ // an instantiation by removing it for others.
+ //
+ template <class It>
+ struct is_readable_iterator_impl2
+ : is_readable_iterator_impl<
+ BOOST_DEDUCED_TYPENAME std::iterator_traits<It>::value_type const
+ >::template rebind<It>
+ {};
+} // namespace detail
+
+template< typename T > struct is_readable_iterator
+: public ::boost::integral_constant<bool,::boost::iterators::detail::is_readable_iterator_impl2<T>::value>
+{
+public:
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_readable_iterator,(T))
+};
+
+} // namespace iterators
+
+using iterators::is_readable_iterator;
+
+} // namespace boost
+
+#endif
+
+#include <boost/iterator/detail/config_undef.hpp>
+
+#endif // IS_READABLE_ITERATOR_DWA2003112_HPP
diff --git a/include/boost/iterator/iterator_adaptor.hpp b/include/boost/iterator/iterator_adaptor.hpp
new file mode 100644
index 0000000..f803fc6
--- /dev/null
+++ b/include/boost/iterator/iterator_adaptor.hpp
@@ -0,0 +1,358 @@
+// (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/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/include/boost/iterator/iterator_archetypes.hpp b/include/boost/iterator/iterator_archetypes.hpp
new file mode 100644
index 0000000..1d25915
--- /dev/null
+++ b/include/boost/iterator/iterator_archetypes.hpp
@@ -0,0 +1,509 @@
+// (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_ARCHETYPES_HPP
+#define BOOST_ITERATOR_ARCHETYPES_HPP
+
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/operators.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/iterator/detail/facade_iterator_category.hpp>
+
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+
+#include <boost/concept_archetype.hpp>
+
+#include <boost/mpl/bitand.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/identity.hpp>
+
+#include <cstddef>
+
+namespace boost {
+namespace iterators {
+
+template <class Value, class AccessCategory>
+struct access_archetype;
+
+template <class Derived, class Value, class AccessCategory, class TraversalCategory>
+struct traversal_archetype;
+
+namespace archetypes
+{
+ enum {
+ readable_iterator_bit = 1
+ , writable_iterator_bit = 2
+ , swappable_iterator_bit = 4
+ , lvalue_iterator_bit = 8
+ };
+
+ // Not quite tags, since dispatching wouldn't work.
+ typedef mpl::int_<readable_iterator_bit>::type readable_iterator_t;
+ typedef mpl::int_<writable_iterator_bit>::type writable_iterator_t;
+
+ typedef mpl::int_<
+ (readable_iterator_bit|writable_iterator_bit)
+ >::type readable_writable_iterator_t;
+
+ typedef mpl::int_<
+ (readable_iterator_bit|lvalue_iterator_bit)
+ >::type readable_lvalue_iterator_t;
+
+ typedef mpl::int_<
+ (lvalue_iterator_bit|writable_iterator_bit)
+ >::type writable_lvalue_iterator_t;
+
+ typedef mpl::int_<swappable_iterator_bit>::type swappable_iterator_t;
+ typedef mpl::int_<lvalue_iterator_bit>::type lvalue_iterator_t;
+
+ template <class Derived, class Base>
+ struct has_access
+ : mpl::equal_to<
+ mpl::bitand_<Derived,Base>
+ , Base
+ >
+ {};
+}
+
+namespace detail
+{
+ template <class T>
+ struct assign_proxy
+ {
+ assign_proxy& operator=(T) { return *this; }
+ };
+
+ template <class T>
+ struct read_proxy
+ {
+ operator T() { return static_object<T>::get(); }
+ };
+
+ template <class T>
+ struct read_write_proxy
+ : read_proxy<T> // Use to inherit from assign_proxy, but that doesn't work. -JGS
+ {
+ read_write_proxy& operator=(T) { return *this; }
+ };
+
+ template <class T>
+ struct arrow_proxy
+ {
+ T const* operator->() const { return 0; }
+ };
+
+ struct no_operator_brackets {};
+
+ template <class ValueType>
+ struct readable_operator_brackets
+ {
+ read_proxy<ValueType> operator[](std::ptrdiff_t n) const { return read_proxy<ValueType>(); }
+ };
+
+ template <class ValueType>
+ struct writable_operator_brackets
+ {
+ read_write_proxy<ValueType> operator[](std::ptrdiff_t n) const { return read_write_proxy<ValueType>(); }
+ };
+
+ template <class Value, class AccessCategory, class TraversalCategory>
+ struct operator_brackets
+ : mpl::eval_if<
+ is_convertible<TraversalCategory, random_access_traversal_tag>
+ , mpl::eval_if<
+ archetypes::has_access<
+ AccessCategory
+ , archetypes::writable_iterator_t
+ >
+ , mpl::identity<writable_operator_brackets<Value> >
+ , mpl::if_<
+ archetypes::has_access<
+ AccessCategory
+ , archetypes::readable_iterator_t
+ >
+ , readable_operator_brackets<Value>
+ , no_operator_brackets
+ >
+ >
+ , mpl::identity<no_operator_brackets>
+ >::type
+ {};
+
+ template <class TraversalCategory>
+ struct traversal_archetype_impl
+ {
+ template <class Derived,class Value> struct archetype;
+ };
+
+ // Constructor argument for those iterators that
+ // are not default constructible
+ struct ctor_arg {};
+
+ template <class Derived, class Value, class TraversalCategory>
+ struct traversal_archetype_
+ : traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
+ {
+ typedef typename
+ traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
+ base;
+
+ traversal_archetype_() {}
+
+ traversal_archetype_(ctor_arg arg)
+ : base(arg)
+ {}
+ };
+
+ template <>
+ struct traversal_archetype_impl<incrementable_traversal_tag>
+ {
+ template<class Derived, class Value>
+ struct archetype
+ {
+ explicit archetype(ctor_arg) {}
+
+ struct bogus { }; // This use to be void, but that causes trouble for iterator_facade. Need more research. -JGS
+ typedef bogus difference_type;
+
+ Derived& operator++() { return (Derived&)static_object<Derived>::get(); }
+ Derived operator++(int) const { return (Derived&)static_object<Derived>::get(); }
+ };
+ };
+
+ template <>
+ struct traversal_archetype_impl<single_pass_traversal_tag>
+ {
+ template<class Derived, class Value>
+ struct archetype
+ : public equality_comparable< traversal_archetype_<Derived, Value, single_pass_traversal_tag> >,
+ public traversal_archetype_<Derived, Value, incrementable_traversal_tag>
+ {
+ explicit archetype(ctor_arg arg)
+ : traversal_archetype_<Derived, Value, incrementable_traversal_tag>(arg)
+ {}
+
+ typedef std::ptrdiff_t difference_type;
+ };
+ };
+
+ template <class Derived, class Value>
+ bool operator==(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&,
+ traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&) { return true; }
+
+ template <>
+ struct traversal_archetype_impl<forward_traversal_tag>
+ {
+ template<class Derived, class Value>
+ struct archetype
+ : public traversal_archetype_<Derived, Value, single_pass_traversal_tag>
+ {
+ archetype()
+ : traversal_archetype_<Derived, Value, single_pass_traversal_tag>(ctor_arg())
+ {}
+ };
+ };
+
+ template <>
+ struct traversal_archetype_impl<bidirectional_traversal_tag>
+ {
+ template<class Derived, class Value>
+ struct archetype
+ : public traversal_archetype_<Derived, Value, forward_traversal_tag>
+ {
+ Derived& operator--() { return static_object<Derived>::get(); }
+ Derived operator--(int) const { return static_object<Derived>::get(); }
+ };
+ };
+
+ template <>
+ struct traversal_archetype_impl<random_access_traversal_tag>
+ {
+ template<class Derived, class Value>
+ struct archetype
+ : public traversal_archetype_<Derived, Value, bidirectional_traversal_tag>
+ {
+ Derived& operator+=(std::ptrdiff_t) { return static_object<Derived>::get(); }
+ Derived& operator-=(std::ptrdiff_t) { return static_object<Derived>::get(); }
+ };
+ };
+
+ template <class Derived, class Value>
+ Derived& operator+(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+ std::ptrdiff_t) { return static_object<Derived>::get(); }
+
+ template <class Derived, class Value>
+ Derived& operator+(std::ptrdiff_t,
+ traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+ { return static_object<Derived>::get(); }
+
+ template <class Derived, class Value>
+ Derived& operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+ std::ptrdiff_t)
+ { return static_object<Derived>::get(); }
+
+ template <class Derived, class Value>
+ std::ptrdiff_t operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+ traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+ { return 0; }
+
+ template <class Derived, class Value>
+ bool operator<(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+ traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+ { return true; }
+
+ template <class Derived, class Value>
+ bool operator>(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+ traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+ { return true; }
+
+ template <class Derived, class Value>
+ bool operator<=(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+ traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+ { return true; }
+
+ template <class Derived, class Value>
+ bool operator>=(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+ traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+ { return true; }
+
+ struct bogus_type;
+
+ template <class Value>
+ struct convertible_type
+ : mpl::if_< is_const<Value>,
+ typename remove_const<Value>::type,
+ bogus_type >
+ {};
+
+} // namespace detail
+
+
+template <class> struct undefined;
+
+template <class AccessCategory>
+struct iterator_access_archetype_impl
+{
+ template <class Value> struct archetype;
+};
+
+template <class Value, class AccessCategory>
+struct iterator_access_archetype
+ : iterator_access_archetype_impl<
+ AccessCategory
+ >::template archetype<Value>
+{
+};
+
+template <>
+struct iterator_access_archetype_impl<
+ archetypes::readable_iterator_t
+>
+{
+ template <class Value>
+ struct archetype
+ {
+ typedef typename remove_cv<Value>::type value_type;
+ typedef Value reference;
+ typedef Value* pointer;
+
+ value_type operator*() const { return static_object<value_type>::get(); }
+
+ detail::arrow_proxy<Value> operator->() const { return detail::arrow_proxy<Value>(); }
+ };
+};
+
+template <>
+struct iterator_access_archetype_impl<
+ archetypes::writable_iterator_t
+>
+{
+ template <class Value>
+ struct archetype
+ {
+ BOOST_STATIC_ASSERT(!is_const<Value>::value);
+ typedef void value_type;
+ typedef void reference;
+ typedef void pointer;
+
+ detail::assign_proxy<Value> operator*() const { return detail::assign_proxy<Value>(); }
+ };
+};
+
+template <>
+struct iterator_access_archetype_impl<
+ archetypes::readable_writable_iterator_t
+>
+{
+ template <class Value>
+ struct archetype
+ : public virtual iterator_access_archetype<
+ Value, archetypes::readable_iterator_t
+ >
+ {
+ typedef detail::read_write_proxy<Value> reference;
+
+ detail::read_write_proxy<Value> operator*() const { return detail::read_write_proxy<Value>(); }
+ };
+};
+
+template <>
+struct iterator_access_archetype_impl<archetypes::readable_lvalue_iterator_t>
+{
+ template <class Value>
+ struct archetype
+ : public virtual iterator_access_archetype<
+ Value, archetypes::readable_iterator_t
+ >
+ {
+ typedef Value& reference;
+
+ Value& operator*() const { return static_object<Value>::get(); }
+ Value* operator->() const { return 0; }
+ };
+};
+
+template <>
+struct iterator_access_archetype_impl<archetypes::writable_lvalue_iterator_t>
+{
+ template <class Value>
+ struct archetype
+ : public virtual iterator_access_archetype<
+ Value, archetypes::readable_lvalue_iterator_t
+ >
+ {
+ BOOST_STATIC_ASSERT((!is_const<Value>::value));
+ };
+};
+
+
+template <class Value, class AccessCategory, class TraversalCategory>
+struct iterator_archetype;
+
+template <class Value, class AccessCategory, class TraversalCategory>
+struct traversal_archetype_base
+ : detail::operator_brackets<
+ typename remove_cv<Value>::type
+ , AccessCategory
+ , TraversalCategory
+ >
+ , detail::traversal_archetype_<
+ iterator_archetype<Value, AccessCategory, TraversalCategory>
+ , Value
+ , TraversalCategory
+ >
+{
+};
+
+namespace detail
+{
+ template <class Value, class AccessCategory, class TraversalCategory>
+ struct iterator_archetype_base
+ : iterator_access_archetype<Value, AccessCategory>
+ , traversal_archetype_base<Value, AccessCategory, TraversalCategory>
+ {
+ typedef iterator_access_archetype<Value, AccessCategory> access;
+
+ typedef typename detail::facade_iterator_category<
+ TraversalCategory
+ , typename mpl::eval_if<
+ archetypes::has_access<
+ AccessCategory, archetypes::writable_iterator_t
+ >
+ , remove_const<Value>
+ , add_const<Value>
+ >::type
+ , typename access::reference
+ >::type iterator_category;
+
+ // Needed for some broken libraries (see below)
+ struct workaround_iterator_base
+ {
+ typedef typename iterator_archetype_base::iterator_category iterator_category;
+ typedef Value value_type;
+ typedef typename traversal_archetype_base<
+ Value, AccessCategory, TraversalCategory
+ >::difference_type difference_type;
+ typedef typename access::pointer pointer;
+ typedef typename access::reference reference;
+ };
+ };
+}
+
+template <class Value, class AccessCategory, class TraversalCategory>
+struct iterator_archetype
+ : public detail::iterator_archetype_base<Value, AccessCategory, TraversalCategory>
+
+ // These broken libraries require derivation from std::iterator
+ // (or related magic) in order to handle iter_swap and other
+ // iterator operations
+# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, < 310) \
+ || BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(0x20101))
+ , public detail::iterator_archetype_base<
+ Value, AccessCategory, TraversalCategory
+ >::workaround_iterator_base
+# endif
+{
+ // Derivation from std::iterator above caused references to nested
+ // types to be ambiguous, so now we have to redeclare them all
+ // here.
+# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, < 310) \
+ || BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(0x20101))
+
+ typedef detail::iterator_archetype_base<
+ Value,AccessCategory,TraversalCategory
+ > base;
+
+ typedef typename base::value_type value_type;
+ typedef typename base::reference reference;
+ typedef typename base::pointer pointer;
+ typedef typename base::difference_type difference_type;
+ typedef typename base::iterator_category iterator_category;
+# endif
+
+ iterator_archetype() { }
+ iterator_archetype(iterator_archetype const& x)
+ : detail::iterator_archetype_base<
+ Value
+ , AccessCategory
+ , TraversalCategory
+ >(x)
+ {}
+
+ iterator_archetype& operator=(iterator_archetype const&)
+ { return *this; }
+
+# if 0
+ // Optional conversion from mutable
+ iterator_archetype(
+ iterator_archetype<
+ typename detail::convertible_type<Value>::type
+ , AccessCategory
+ , TraversalCategory> const&
+ );
+# endif
+};
+
+} // namespace iterators
+
+// Backward compatibility names
+namespace iterator_archetypes = iterators::archetypes;
+using iterators::access_archetype;
+using iterators::traversal_archetype;
+using iterators::iterator_archetype;
+using iterators::undefined;
+using iterators::iterator_access_archetype_impl;
+using iterators::traversal_archetype_base;
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_ARCHETYPES_HPP
diff --git a/include/boost/iterator/iterator_categories.hpp b/include/boost/iterator/iterator_categories.hpp
new file mode 100644
index 0000000..baf805a
--- /dev/null
+++ b/include/boost/iterator/iterator_categories.hpp
@@ -0,0 +1,216 @@
+// (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/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>
+
+#include <iterator>
+
+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 std::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/include/boost/iterator/iterator_concepts.hpp b/include/boost/iterator/iterator_concepts.hpp
new file mode 100644
index 0000000..415cc49
--- /dev/null
+++ b/include/boost/iterator/iterator_concepts.hpp
@@ -0,0 +1,273 @@
+// (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>
+
+#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 <iterator>
+
+#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 std::iterator_traits<Iterator>::value_type value_type;
+ typedef BOOST_DEDUCED_TYPENAME std::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 std::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 std::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 std::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 std::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 std::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/include/boost/iterator/iterator_facade.hpp b/include/boost/iterator/iterator_facade.hpp
new file mode 100644
index 0000000..225c53a
--- /dev/null
+++ b/include/boost/iterator/iterator_facade.hpp
@@ -0,0 +1,981 @@
+// (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/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 <cstddef>
+
+#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/include/boost/iterator/iterator_traits.hpp b/include/boost/iterator/iterator_traits.hpp
new file mode 100644
index 0000000..6582a68
--- /dev/null
+++ b/include/boost/iterator/iterator_traits.hpp
@@ -0,0 +1,61 @@
+// 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/workaround.hpp>
+
+#include <iterator>
+
+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 std::iterator_traits<Iterator>::value_type type;
+};
+
+template <class Iterator>
+struct iterator_reference
+{
+ typedef typename std::iterator_traits<Iterator>::reference type;
+};
+
+
+template <class Iterator>
+struct iterator_pointer
+{
+ typedef typename std::iterator_traits<Iterator>::pointer type;
+};
+
+template <class Iterator>
+struct iterator_difference
+{
+ typedef typename std::iterator_traits<Iterator>::difference_type type;
+};
+
+template <class Iterator>
+struct iterator_category
+{
+ typedef typename std::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/include/boost/iterator/minimum_category.hpp b/include/boost/iterator/minimum_category.hpp
new file mode 100644
index 0000000..15679bc
--- /dev/null
+++ b/include/boost/iterator/minimum_category.hpp
@@ -0,0 +1,95 @@
+// 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 BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_
+# define BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_
+
+# include <boost/static_assert.hpp>
+# include <boost/type_traits/is_convertible.hpp>
+# include <boost/type_traits/is_same.hpp>
+
+# include <boost/mpl/placeholders.hpp>
+# include <boost/mpl/aux_/lambda_support.hpp>
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+template <bool GreaterEqual, bool LessEqual>
+struct minimum_category_impl;
+
+template <class T1, class T2>
+struct error_not_related_by_convertibility;
+
+template <>
+struct minimum_category_impl<true,false>
+{
+ template <class T1, class T2> struct apply
+ {
+ typedef T2 type;
+ };
+};
+
+template <>
+struct minimum_category_impl<false,true>
+{
+ template <class T1, class T2> struct apply
+ {
+ typedef T1 type;
+ };
+};
+
+template <>
+struct minimum_category_impl<true,true>
+{
+ template <class T1, class T2> struct apply
+ {
+ BOOST_STATIC_ASSERT((is_same<T1,T2>::value));
+ typedef T1 type;
+ };
+};
+
+template <>
+struct minimum_category_impl<false,false>
+{
+ template <class T1, class T2> struct apply
+ : error_not_related_by_convertibility<T1,T2>
+ {
+ };
+};
+
+} // namespace detail
+
+//
+// Returns the minimum category type or fails to compile
+// if T1 and T2 are unrelated.
+//
+template <class T1 = mpl::_1, class T2 = mpl::_2>
+struct minimum_category
+{
+ typedef boost::iterators::detail::minimum_category_impl<
+ ::boost::is_convertible<T1,T2>::value
+ , ::boost::is_convertible<T2,T1>::value
+ > outer;
+
+ typedef typename outer::template apply<T1,T2> inner;
+ typedef typename inner::type type;
+
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(2,minimum_category,(T1,T2))
+};
+
+template <>
+struct minimum_category<mpl::_1,mpl::_2>
+{
+ template <class T1, class T2>
+ struct apply : minimum_category<T1,T2>
+ {};
+
+ BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,minimum_category,(mpl::_1,mpl::_2))
+};
+
+} // namespace iterators
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_
diff --git a/include/boost/iterator/new_iterator_tests.hpp b/include/boost/iterator/new_iterator_tests.hpp
new file mode 100644
index 0000000..a1d3b2f
--- /dev/null
+++ b/include/boost/iterator/new_iterator_tests.hpp
@@ -0,0 +1,265 @@
+#ifndef BOOST_NEW_ITERATOR_TESTS_HPP
+# define BOOST_NEW_ITERATOR_TESTS_HPP
+
+//
+// Copyright (c) David Abrahams 2001.
+// Copyright (c) Jeremy Siek 2001-2003.
+// Copyright (c) Thomas Witt 2002.
+//
+// Use, modification and distribution is subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// This is meant to be the beginnings of a comprehensive, generic
+// test suite for STL concepts such as iterators and containers.
+//
+// Revision History:
+// 28 Oct 2002 Started update for new iterator categories
+// (Jeremy Siek)
+// 28 Apr 2002 Fixed input iterator requirements.
+// For a == b a++ == b++ is no longer required.
+// See 24.1.1/3 for details.
+// (Thomas Witt)
+// 08 Feb 2001 Fixed bidirectional iterator test so that
+// --i is no longer a precondition.
+// (Jeremy Siek)
+// 04 Feb 2001 Added lvalue test, corrected preconditions
+// (David Abrahams)
+
+# include <iterator>
+# include <boost/static_assert.hpp>
+# include <boost/concept_archetype.hpp> // for detail::dummy_constructor
+# include <boost/pending/iterator_tests.hpp>
+# include <boost/iterator/is_readable_iterator.hpp>
+# include <boost/iterator/is_lvalue_iterator.hpp>
+# include <boost/type_traits/is_same.hpp>
+# include <boost/mpl/bool.hpp>
+# include <boost/mpl/and.hpp>
+
+# include <boost/iterator/detail/config_def.hpp>
+# include <boost/detail/is_incrementable.hpp>
+# include <boost/core/lightweight_test.hpp>
+
+namespace boost {
+
+
+// Do separate tests for *i++ so we can treat, e.g., smart pointers,
+// as readable and/or writable iterators.
+template <class Iterator, class T>
+void readable_iterator_traversal_test(Iterator i1, T v, mpl::true_)
+{
+ T v2(*i1++);
+ BOOST_TEST(v == v2);
+}
+
+template <class Iterator, class T>
+void readable_iterator_traversal_test(const Iterator i1, T v, mpl::false_)
+{}
+
+template <class Iterator, class T>
+void writable_iterator_traversal_test(Iterator i1, T v, mpl::true_)
+{
+ ++i1; // we just wrote into that position
+ *i1++ = v;
+ Iterator x(i1++);
+ (void)x;
+}
+
+template <class Iterator, class T>
+void writable_iterator_traversal_test(const Iterator i1, T v, mpl::false_)
+{}
+
+
+// Preconditions: *i == v
+template <class Iterator, class T>
+void readable_iterator_test(const Iterator i1, T v)
+{
+ Iterator i2(i1); // Copy Constructible
+ typedef typename std::iterator_traits<Iterator>::reference ref_t;
+ ref_t r1 = *i1;
+ ref_t r2 = *i2;
+ T v1 = r1;
+ T v2 = r2;
+ BOOST_TEST(v1 == v);
+ BOOST_TEST(v2 == v);
+
+# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
+ readable_iterator_traversal_test(i1, v, detail::is_postfix_incrementable<Iterator>());
+
+ // I think we don't really need this as it checks the same things as
+ // the above code.
+ BOOST_STATIC_ASSERT(is_readable_iterator<Iterator>::value);
+# endif
+}
+
+template <class Iterator, class T>
+void writable_iterator_test(Iterator i, T v, T v2)
+{
+ Iterator i2(i); // Copy Constructible
+ *i2 = v;
+
+# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
+ writable_iterator_traversal_test(
+ i, v2, mpl::and_<
+ detail::is_incrementable<Iterator>
+ , detail::is_postfix_incrementable<Iterator>
+ >());
+# endif
+}
+
+template <class Iterator>
+void swappable_iterator_test(Iterator i, Iterator j)
+{
+ Iterator i2(i), j2(j);
+ typename std::iterator_traits<Iterator>::value_type bi = *i, bj = *j;
+ iter_swap(i2, j2);
+ typename std::iterator_traits<Iterator>::value_type ai = *i, aj = *j;
+ BOOST_TEST(bi == aj && bj == ai);
+}
+
+template <class Iterator, class T>
+void constant_lvalue_iterator_test(Iterator i, T v1)
+{
+ Iterator i2(i);
+ typedef typename std::iterator_traits<Iterator>::value_type value_type;
+ typedef typename std::iterator_traits<Iterator>::reference reference;
+ BOOST_STATIC_ASSERT((is_same<const value_type&, reference>::value));
+ const T& v2 = *i2;
+ BOOST_TEST(v1 == v2);
+# ifndef BOOST_NO_LVALUE_RETURN_DETECTION
+ BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value);
+ BOOST_STATIC_ASSERT(!is_non_const_lvalue_iterator<Iterator>::value);
+# endif
+}
+
+template <class Iterator, class T>
+void non_const_lvalue_iterator_test(Iterator i, T v1, T v2)
+{
+ Iterator i2(i);
+ typedef typename std::iterator_traits<Iterator>::value_type value_type;
+ typedef typename std::iterator_traits<Iterator>::reference reference;
+ BOOST_STATIC_ASSERT((is_same<value_type&, reference>::value));
+ T& v3 = *i2;
+ BOOST_TEST(v1 == v3);
+
+ // A non-const lvalue iterator is not neccessarily writable, but we
+ // are assuming the value_type is assignable here
+ *i = v2;
+
+ T& v4 = *i2;
+ BOOST_TEST(v2 == v4);
+# ifndef BOOST_NO_LVALUE_RETURN_DETECTION
+ BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value);
+ BOOST_STATIC_ASSERT(is_non_const_lvalue_iterator<Iterator>::value);
+# endif
+}
+
+template <class Iterator, class T>
+void forward_readable_iterator_test(Iterator i, Iterator j, T val1, T val2)
+{
+ Iterator i2;
+ Iterator i3(i);
+ i2 = i;
+ BOOST_TEST(i2 == i3);
+ BOOST_TEST(i != j);
+ BOOST_TEST(i2 != j);
+ readable_iterator_test(i, val1);
+ readable_iterator_test(i2, val1);
+ readable_iterator_test(i3, val1);
+
+ BOOST_TEST(i == i2++);
+ BOOST_TEST(i != ++i3);
+
+ readable_iterator_test(i2, val2);
+ readable_iterator_test(i3, val2);
+
+ readable_iterator_test(i, val1);
+}
+
+template <class Iterator, class T>
+void forward_swappable_iterator_test(Iterator i, Iterator j, T val1, T val2)
+{
+ forward_readable_iterator_test(i, j, val1, val2);
+ Iterator i2 = i;
+ ++i2;
+ swappable_iterator_test(i, i2);
+}
+
+// bidirectional
+// Preconditions: *i == v1, *++i == v2
+template <class Iterator, class T>
+void bidirectional_readable_iterator_test(Iterator i, T v1, T v2)
+{
+ Iterator j(i);
+ ++j;
+ forward_readable_iterator_test(i, j, v1, v2);
+ ++i;
+
+ Iterator i1 = i, i2 = i;
+
+ BOOST_TEST(i == i1--);
+ BOOST_TEST(i != --i2);
+
+ readable_iterator_test(i, v2);
+ readable_iterator_test(i1, v1);
+ readable_iterator_test(i2, v1);
+
+ --i;
+ BOOST_TEST(i == i1);
+ BOOST_TEST(i == i2);
+ ++i1;
+ ++i2;
+
+ readable_iterator_test(i, v1);
+ readable_iterator_test(i1, v2);
+ readable_iterator_test(i2, v2);
+}
+
+// random access
+// Preconditions: [i,i+N) is a valid range
+template <class Iterator, class TrueVals>
+void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals)
+{
+ bidirectional_readable_iterator_test(i, vals[0], vals[1]);
+ const Iterator j = i;
+ int c;
+
+ for (c = 0; c < N-1; ++c)
+ {
+ BOOST_TEST(i == j + c);
+ BOOST_TEST(*i == vals[c]);
+ typename std::iterator_traits<Iterator>::value_type x = j[c];
+ BOOST_TEST(*i == x);
+ BOOST_TEST(*i == *(j + c));
+ BOOST_TEST(*i == *(c + j));
+ ++i;
+ BOOST_TEST(i > j);
+ BOOST_TEST(i >= j);
+ BOOST_TEST(j <= i);
+ BOOST_TEST(j < i);
+ }
+
+ Iterator k = j + N - 1;
+ for (c = 0; c < N-1; ++c)
+ {
+ BOOST_TEST(i == k - c);
+ BOOST_TEST(*i == vals[N - 1 - c]);
+ typename std::iterator_traits<Iterator>::value_type x = j[N - 1 - c];
+ BOOST_TEST(*i == x);
+ Iterator q = k - c;
+ BOOST_TEST(*i == *q);
+ BOOST_TEST(i > j);
+ BOOST_TEST(i >= j);
+ BOOST_TEST(j <= i);
+ BOOST_TEST(j < i);
+ --i;
+ }
+}
+
+} // namespace boost
+
+# include <boost/iterator/detail/config_undef.hpp>
+
+#endif // BOOST_NEW_ITERATOR_TESTS_HPP
diff --git a/include/boost/iterator/permutation_iterator.hpp b/include/boost/iterator/permutation_iterator.hpp
new file mode 100644
index 0000000..3876f3d
--- /dev/null
+++ b/include/boost/iterator/permutation_iterator.hpp
@@ -0,0 +1,76 @@
+// (C) Copyright Toon Knapen 2001.
+// (C) Copyright David Abrahams 2003.
+// (C) Copyright Roland Richter 2003.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PERMUTATION_ITERATOR_HPP
+#define BOOST_PERMUTATION_ITERATOR_HPP
+
+#include <iterator>
+
+#include <boost/iterator/iterator_adaptor.hpp>
+
+
+namespace boost {
+namespace iterators {
+
+template< class ElementIterator
+ , class IndexIterator>
+class permutation_iterator
+ : public iterator_adaptor<
+ permutation_iterator<ElementIterator, IndexIterator>
+ , IndexIterator, typename std::iterator_traits<ElementIterator>::value_type
+ , use_default, typename std::iterator_traits<ElementIterator>::reference>
+{
+ typedef iterator_adaptor<
+ permutation_iterator<ElementIterator, IndexIterator>
+ , IndexIterator, typename std::iterator_traits<ElementIterator>::value_type
+ , use_default, typename std::iterator_traits<ElementIterator>::reference> super_t;
+
+ friend class iterator_core_access;
+
+public:
+ permutation_iterator() : m_elt_iter() {}
+
+ explicit permutation_iterator(ElementIterator x, IndexIterator y)
+ : super_t(y), m_elt_iter(x) {}
+
+ template<class OtherElementIterator, class OtherIndexIterator>
+ permutation_iterator(
+ permutation_iterator<OtherElementIterator, OtherIndexIterator> const& r
+ , typename enable_if_convertible<OtherElementIterator, ElementIterator>::type* = 0
+ , typename enable_if_convertible<OtherIndexIterator, IndexIterator>::type* = 0
+ )
+ : super_t(r.base()), m_elt_iter(r.m_elt_iter)
+ {}
+
+private:
+ typename super_t::reference dereference() const
+ { return *(m_elt_iter + *this->base()); }
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+ template <class,class> friend class permutation_iterator;
+#else
+ public:
+#endif
+ ElementIterator m_elt_iter;
+};
+
+
+template <class ElementIterator, class IndexIterator>
+inline permutation_iterator<ElementIterator, IndexIterator>
+make_permutation_iterator( ElementIterator e, IndexIterator i )
+{
+ return permutation_iterator<ElementIterator, IndexIterator>( e, i );
+}
+
+} // namespace iterators
+
+using iterators::permutation_iterator;
+using iterators::make_permutation_iterator;
+
+} // namespace boost
+
+#endif
diff --git a/include/boost/iterator/reverse_iterator.hpp b/include/boost/iterator/reverse_iterator.hpp
new file mode 100644
index 0000000..03b7925
--- /dev/null
+++ b/include/boost/iterator/reverse_iterator.hpp
@@ -0,0 +1,77 @@
+// (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/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
+ {
+ Iterator it = this->base_reference();
+ --it;
+ return *it;
+ }
+
+ 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/include/boost/iterator/transform_iterator.hpp b/include/boost/iterator/transform_iterator.hpp
new file mode 100644
index 0000000..2281df8
--- /dev/null
+++ b/include/boost/iterator/transform_iterator.hpp
@@ -0,0 +1,175 @@
+// (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/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>
+
+#include <iterator>
+
+#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
+#ifdef BOOST_RESULT_OF_USE_TR1
+ , result_of<const UnaryFunc(typename std::iterator_traits<Iterator>::reference)>
+#else
+ , result_of<const UnaryFunc&(typename std::iterator_traits<Iterator>::reference)>
+#endif
+ >::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
diff --git a/include/boost/iterator/zip_iterator.hpp b/include/boost/iterator/zip_iterator.hpp
new file mode 100644
index 0000000..f5780ae
--- /dev/null
+++ b/include/boost/iterator/zip_iterator.hpp
@@ -0,0 +1,367 @@
+// Copyright David Abrahams and Thomas Becker 2000-2006.
+// Copyright Kohei Takahashi 2012-2014.
+//
+// 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_ZIP_ITERATOR_TMB_07_13_2003_HPP_
+# define BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_
+
+#include <stddef.h>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/iterator_adaptor.hpp> // for enable_if_convertible
+#include <boost/iterator/iterator_categories.hpp>
+
+#include <boost/iterator/minimum_category.hpp>
+
+#include <utility> // for std::pair
+#include <boost/fusion/adapted/boost_tuple.hpp> // for backward compatibility
+
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/mpl/placeholders.hpp>
+
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+#include <boost/fusion/algorithm/transformation/transform.hpp>
+#include <boost/fusion/sequence/convert.hpp>
+#include <boost/fusion/sequence/intrinsic/at_c.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/support/tag_of_fwd.hpp>
+
+namespace boost {
+namespace iterators {
+
+ // Zip iterator forward declaration for zip_iterator_base
+ template<typename IteratorTuple>
+ class zip_iterator;
+
+ namespace detail
+ {
+
+ // Functors to be used with tuple algorithms
+ //
+ template<typename DiffType>
+ class advance_iterator
+ {
+ public:
+ advance_iterator(DiffType step) : m_step(step) {}
+
+ template<typename Iterator>
+ void operator()(Iterator& it) const
+ { it += m_step; }
+
+ private:
+ DiffType m_step;
+ };
+ //
+ struct increment_iterator
+ {
+ template<typename Iterator>
+ void operator()(Iterator& it) const
+ { ++it; }
+ };
+ //
+ struct decrement_iterator
+ {
+ template<typename Iterator>
+ void operator()(Iterator& it) const
+ { --it; }
+ };
+ //
+ struct dereference_iterator
+ {
+ template<typename>
+ struct result;
+
+ template<typename This, typename Iterator>
+ struct result<This(Iterator)>
+ {
+ typedef typename
+ remove_cv<typename remove_reference<Iterator>::type>::type
+ iterator;
+
+ typedef typename iterator_reference<iterator>::type type;
+ };
+
+ template<typename Iterator>
+ typename result<dereference_iterator(Iterator)>::type
+ operator()(Iterator const& it) const
+ { return *it; }
+ };
+
+ // Metafunction to obtain the type of the tuple whose element types
+ // are the reference types of an iterator tuple.
+ //
+ template<typename IteratorTuple>
+ struct tuple_of_references
+ : mpl::transform<
+ IteratorTuple,
+ iterator_reference<mpl::_1>
+ >
+ {
+ };
+
+ // Specialization for std::pair
+ template<typename Iterator1, typename Iterator2>
+ struct tuple_of_references<std::pair<Iterator1, Iterator2> >
+ {
+ typedef std::pair<
+ typename iterator_reference<Iterator1>::type
+ , typename iterator_reference<Iterator2>::type
+ > type;
+ };
+
+ // Metafunction to obtain the minimal traversal tag in a tuple
+ // of iterators.
+ //
+ template<typename IteratorTuple>
+ struct minimum_traversal_category_in_iterator_tuple
+ {
+ typedef typename mpl::transform<
+ IteratorTuple
+ , pure_traversal_tag<iterator_traversal<> >
+ >::type tuple_of_traversal_tags;
+
+ typedef typename mpl::fold<
+ tuple_of_traversal_tags
+ , random_access_traversal_tag
+ , minimum_category<>
+ >::type type;
+ };
+
+ template<typename Iterator1, typename Iterator2>
+ struct minimum_traversal_category_in_iterator_tuple<std::pair<Iterator1, Iterator2> >
+ {
+ typedef typename pure_traversal_tag<
+ typename iterator_traversal<Iterator1>::type
+ >::type iterator1_traversal;
+ typedef typename pure_traversal_tag<
+ typename iterator_traversal<Iterator2>::type
+ >::type iterator2_traversal;
+
+ typedef typename minimum_category<
+ iterator1_traversal
+ , typename minimum_category<
+ iterator2_traversal
+ , random_access_traversal_tag
+ >::type
+ >::type type;
+ };
+
+ ///////////////////////////////////////////////////////////////////
+ //
+ // Class zip_iterator_base
+ //
+ // Builds and exposes the iterator facade type from which the zip
+ // iterator will be derived.
+ //
+ template<typename IteratorTuple>
+ struct zip_iterator_base
+ {
+ private:
+ // Reference type is the type of the tuple obtained from the
+ // iterators' reference types.
+ typedef typename
+ detail::tuple_of_references<IteratorTuple>::type reference;
+
+ // Value type is the same as reference type.
+ typedef reference value_type;
+
+ // Difference type is the first iterator's difference type
+ typedef typename iterator_difference<
+ typename mpl::at_c<IteratorTuple, 0>::type
+ >::type difference_type;
+
+ // Traversal catetgory is the minimum traversal category in the
+ // iterator tuple.
+ typedef typename
+ detail::minimum_traversal_category_in_iterator_tuple<
+ IteratorTuple
+ >::type traversal_category;
+ public:
+
+ // The iterator facade type from which the zip iterator will
+ // be derived.
+ typedef iterator_facade<
+ zip_iterator<IteratorTuple>,
+ value_type,
+ traversal_category,
+ reference,
+ difference_type
+ > type;
+ };
+
+ template <>
+ struct zip_iterator_base<int>
+ {
+ typedef int type;
+ };
+
+ template <typename reference>
+ struct converter
+ {
+ template <typename Seq>
+ static reference call(Seq seq)
+ {
+ typedef typename fusion::traits::tag_of<reference>::type tag;
+ return fusion::convert<tag>(seq);
+ }
+ };
+
+ template <typename Reference1, typename Reference2>
+ struct converter<std::pair<Reference1, Reference2> >
+ {
+ typedef std::pair<Reference1, Reference2> reference;
+ template <typename Seq>
+ static reference call(Seq seq)
+ {
+ return reference(
+ fusion::at_c<0>(seq)
+ , fusion::at_c<1>(seq));
+ }
+ };
+ }
+
+ /////////////////////////////////////////////////////////////////////
+ //
+ // zip_iterator class definition
+ //
+ template<typename IteratorTuple>
+ class zip_iterator :
+ public detail::zip_iterator_base<IteratorTuple>::type
+ {
+
+ // Typedef super_t as our base class.
+ typedef typename
+ detail::zip_iterator_base<IteratorTuple>::type super_t;
+
+ // iterator_core_access is the iterator's best friend.
+ friend class iterator_core_access;
+
+ public:
+
+ // Construction
+ // ============
+
+ // Default constructor
+ zip_iterator() { }
+
+ // Constructor from iterator tuple
+ zip_iterator(IteratorTuple iterator_tuple)
+ : m_iterator_tuple(iterator_tuple)
+ { }
+
+ // Copy constructor
+ template<typename OtherIteratorTuple>
+ zip_iterator(
+ const zip_iterator<OtherIteratorTuple>& other,
+ typename enable_if_convertible<
+ OtherIteratorTuple,
+ IteratorTuple
+ >::type* = 0
+ ) : m_iterator_tuple(other.get_iterator_tuple())
+ {}
+
+ // Get method for the iterator tuple.
+ const IteratorTuple& get_iterator_tuple() const
+ { return m_iterator_tuple; }
+
+ private:
+
+ // Implementation of Iterator Operations
+ // =====================================
+
+ // Dereferencing returns a tuple built from the dereferenced
+ // iterators in the iterator tuple.
+ typename super_t::reference dereference() const
+ {
+ typedef typename super_t::reference reference;
+ typedef detail::converter<reference> gen;
+ return gen::call(fusion::transform(
+ get_iterator_tuple(),
+ detail::dereference_iterator()));
+ }
+
+ // Two zip iterators are equal if all iterators in the iterator
+ // tuple are equal. NOTE: It should be possible to implement this
+ // as
+ //
+ // return get_iterator_tuple() == other.get_iterator_tuple();
+ //
+ // but equality of tuples currently (7/2003) does not compile
+ // under several compilers. No point in bringing in a bunch
+ // of #ifdefs here.
+ //
+ template<typename OtherIteratorTuple>
+ bool equal(const zip_iterator<OtherIteratorTuple>& other) const
+ {
+ return fusion::equal_to(
+ get_iterator_tuple(),
+ other.get_iterator_tuple());
+ }
+
+ // Advancing a zip iterator means to advance all iterators in the
+ // iterator tuple.
+ void advance(typename super_t::difference_type n)
+ {
+ fusion::for_each(
+ m_iterator_tuple,
+ detail::advance_iterator<BOOST_DEDUCED_TYPENAME super_t::difference_type>(n));
+ }
+ // Incrementing a zip iterator means to increment all iterators in
+ // the iterator tuple.
+ void increment()
+ {
+ fusion::for_each(
+ m_iterator_tuple,
+ detail::increment_iterator());
+ }
+
+ // Decrementing a zip iterator means to decrement all iterators in
+ // the iterator tuple.
+ void decrement()
+ {
+ fusion::for_each(
+ m_iterator_tuple,
+ detail::decrement_iterator());
+ }
+
+ // Distance is calculated using the first iterator in the tuple.
+ template<typename OtherIteratorTuple>
+ typename super_t::difference_type distance_to(
+ const zip_iterator<OtherIteratorTuple>& other
+ ) const
+ {
+ return fusion::at_c<0>(other.get_iterator_tuple()) -
+ fusion::at_c<0>(this->get_iterator_tuple());
+ }
+
+ // Data Members
+ // ============
+
+ // The iterator tuple.
+ IteratorTuple m_iterator_tuple;
+
+ };
+
+ // Make function for zip iterator
+ //
+ template<typename IteratorTuple>
+ inline zip_iterator<IteratorTuple>
+ make_zip_iterator(IteratorTuple t)
+ { return zip_iterator<IteratorTuple>(t); }
+
+} // namespace iterators
+
+using iterators::zip_iterator;
+using iterators::make_zip_iterator;
+
+} // namespace boost
+
+#endif
diff --git a/include/boost/iterator_adaptors.hpp b/include/boost/iterator_adaptors.hpp
new file mode 100644
index 0000000..ed9579c
--- /dev/null
+++ b/include/boost/iterator_adaptors.hpp
@@ -0,0 +1,13 @@
+// Copyright David Abrahams 2004. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See www.boost.org/libs/iterator for documentation.
+
+#ifndef ITERATOR_ADAPTORS_DWA2004725_HPP
+# define ITERATOR_ADAPTORS_DWA2004725_HPP
+
+#define BOOST_ITERATOR_ADAPTORS_VERSION 0x0200
+#include <boost/iterator/iterator_adaptor.hpp>
+
+#endif // ITERATOR_ADAPTORS_DWA2004725_HPP
diff --git a/include/boost/next_prior.hpp b/include/boost/next_prior.hpp
new file mode 100644
index 0000000..5de705f
--- /dev/null
+++ b/include/boost/next_prior.hpp
@@ -0,0 +1,195 @@
+// Boost next_prior.hpp header file ---------------------------------------//
+
+// (C) Copyright Dave Abrahams and Daniel Walker 1999-2003.
+// Copyright (c) Andrey Semashev 2017
+//
+// 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)
+
+// See http://www.boost.org/libs/utility for documentation.
+
+// Revision History
+// 13 Dec 2003 Added next(x, n) and prior(x, n) (Daniel Walker)
+
+#ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED
+#define BOOST_NEXT_PRIOR_HPP_INCLUDED
+
+#include <iterator>
+#include <boost/config.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/has_plus.hpp>
+#include <boost/type_traits/has_plus_assign.hpp>
+#include <boost/type_traits/has_minus.hpp>
+#include <boost/type_traits/has_minus_assign.hpp>
+#include <boost/iterator/advance.hpp>
+#include <boost/iterator/reverse_iterator.hpp>
+
+namespace boost {
+
+// Helper functions for classes like bidirectional iterators not supporting
+// operator+ and operator-
+//
+// Usage:
+// const std::list<T>::iterator p = get_some_iterator();
+// const std::list<T>::iterator prev = boost::prior(p);
+// const std::list<T>::iterator next = boost::next(prev, 2);
+
+// Contributed by Dave Abrahams
+
+namespace next_prior_detail {
+
+// The trait attempts to detect if the T type is an iterator. Class-type iterators are assumed
+// to have the nested type iterator_category. Strictly speaking, this is not required to be the
+// case (e.g. a user can specialize iterator_traits for T without defining T::iterator_category).
+// Still, this is a good heuristic in practice, and we can't do anything better anyway.
+// Since C++17 we can test for iterator_traits<T>::iterator_category presence instead as it is
+// required to be only present for iterators.
+template< typename T, typename Void = void >
+struct is_iterator_class
+{
+ static BOOST_CONSTEXPR_OR_CONST bool value = false;
+};
+
+template< typename T >
+struct is_iterator_class<
+ T,
+ typename enable_if_has_type<
+#if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS)
+ typename std::iterator_traits< T >::iterator_category
+#else
+ typename T::iterator_category
+#endif
+ >::type
+>
+{
+ static BOOST_CONSTEXPR_OR_CONST bool value = true;
+};
+
+template< typename T >
+struct is_iterator :
+ public is_iterator_class< T >
+{
+};
+
+template< typename T >
+struct is_iterator< T* >
+{
+ static BOOST_CONSTEXPR_OR_CONST bool value = true;
+};
+
+
+template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
+struct next_plus_impl;
+
+template< typename T, typename Distance >
+struct next_plus_impl< T, Distance, true >
+{
+ static T call(T x, Distance n)
+ {
+ return x + n;
+ }
+};
+
+template< typename T, typename Distance, bool HasPlusAssign = has_plus_assign< T, Distance >::value >
+struct next_plus_assign_impl :
+ public next_plus_impl< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct next_plus_assign_impl< T, Distance, true >
+{
+ static T call(T x, Distance n)
+ {
+ x += n;
+ return x;
+ }
+};
+
+template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
+struct next_advance_impl :
+ public next_plus_assign_impl< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct next_advance_impl< T, Distance, true >
+{
+ static T call(T x, Distance n)
+ {
+ boost::iterators::advance(x, n);
+ return x;
+ }
+};
+
+
+template< typename T, typename Distance, bool HasMinus = has_minus< T, Distance >::value >
+struct prior_minus_impl;
+
+template< typename T, typename Distance >
+struct prior_minus_impl< T, Distance, true >
+{
+ static T call(T x, Distance n)
+ {
+ return x - n;
+ }
+};
+
+template< typename T, typename Distance, bool HasMinusAssign = has_minus_assign< T, Distance >::value >
+struct prior_minus_assign_impl :
+ public prior_minus_impl< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct prior_minus_assign_impl< T, Distance, true >
+{
+ static T call(T x, Distance n)
+ {
+ x -= n;
+ return x;
+ }
+};
+
+template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
+struct prior_advance_impl :
+ public prior_minus_assign_impl< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct prior_advance_impl< T, Distance, true >
+{
+ static T call(T x, Distance n)
+ {
+ // Avoid negating n to sidestep possible integer overflow
+ boost::iterators::reverse_iterator< T > rx(x);
+ boost::iterators::advance(rx, n);
+ return rx.base();
+ }
+};
+
+} // namespace next_prior_detail
+
+template <class T>
+inline T next(T x) { return ++x; }
+
+template <class T, class Distance>
+inline T next(T x, Distance n)
+{
+ return next_prior_detail::next_advance_impl< T, Distance >::call(x, n);
+}
+
+template <class T>
+inline T prior(T x) { return --x; }
+
+template <class T, class Distance>
+inline T prior(T x, Distance n)
+{
+ return next_prior_detail::prior_advance_impl< T, Distance >::call(x, n);
+}
+
+} // namespace boost
+
+#endif // BOOST_NEXT_PRIOR_HPP_INCLUDED
diff --git a/include/boost/pending/detail/int_iterator.hpp b/include/boost/pending/detail/int_iterator.hpp
new file mode 100644
index 0000000..dcc7024
--- /dev/null
+++ b/include/boost/pending/detail/int_iterator.hpp
@@ -0,0 +1,82 @@
+// (C) Copyright Jeremy Siek 1999.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_INT_ITERATOR_H
+#define BOOST_INT_ITERATOR_H
+
+#if !defined BOOST_MSVC
+#include <boost/operators.hpp>
+#endif
+#include <iostream>
+#include <iterator>
+#include <cstddef>
+//using namespace std;
+
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+namespace boost {
+namespace iterators {
+#endif
+
+// this should use random_access_iterator_helper but I've had
+// VC++ portablility problems with that. -JGS
+template <class IntT>
+class int_iterator
+{
+ typedef int_iterator self;
+public:
+ typedef std::random_access_iterator_tag iterator_category;
+ typedef IntT value_type;
+ typedef IntT& reference;
+ typedef IntT* pointer;
+ typedef std::ptrdiff_t difference_type;
+
+ inline int_iterator() : _i(0) { }
+ inline int_iterator(IntT i) : _i(i) { }
+ inline int_iterator(const self& x) : _i(x._i) { }
+ inline self& operator=(const self& x) { _i = x._i; return *this; }
+ inline IntT operator*() { return _i; }
+ inline IntT operator[](IntT n) { return _i + n; }
+ inline self& operator++() { ++_i; return *this; }
+ inline self operator++(int) { self t = *this; ++_i; return t; }
+ inline self& operator+=(IntT n) { _i += n; return *this; }
+ inline self operator+(IntT n) { self t = *this; t += n; return t; }
+ inline self& operator--() { --_i; return *this; }
+ inline self operator--(int) { self t = *this; --_i; return t; }
+ inline self& operator-=(IntT n) { _i -= n; return *this; }
+ inline IntT operator-(const self& x) const { return _i - x._i; }
+ inline bool operator==(const self& x) const { return _i == x._i; }
+ // vc++ had a problem finding != in random_access_iterator_helper
+ // need to look into this... for now implementing everything here -JGS
+ inline bool operator!=(const self& x) const { return _i != x._i; }
+ inline bool operator<(const self& x) const { return _i < x._i; }
+ inline bool operator<=(const self& x) const { return _i <= x._i; }
+ inline bool operator>(const self& x) const { return _i > x._i; }
+ inline bool operator>=(const self& x) const { return _i >= x._i; }
+protected:
+ IntT _i;
+};
+
+template <class IntT>
+inline int_iterator<IntT>
+operator+(IntT n, int_iterator<IntT> t) { t += n; return t; }
+
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+} /* namespace iterators */
+
+using iterators::int_iterator;
+
+} /* namespace boost */
+#endif
+
+#ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
+namespace boost {
+using ::int_iterator;
+namespace iterators {
+using ::int_iterator;
+}}
+#endif
+
+
+#endif /* BOOST_INT_ITERATOR_H */
diff --git a/include/boost/pending/iterator_adaptors.hpp b/include/boost/pending/iterator_adaptors.hpp
new file mode 100644
index 0000000..2256e81
--- /dev/null
+++ b/include/boost/pending/iterator_adaptors.hpp
@@ -0,0 +1,6 @@
+// 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)
+
+#include <boost/iterator_adaptors.hpp>
diff --git a/include/boost/pending/iterator_tests.hpp b/include/boost/pending/iterator_tests.hpp
new file mode 100644
index 0000000..b4d2efa
--- /dev/null
+++ b/include/boost/pending/iterator_tests.hpp
@@ -0,0 +1,288 @@
+// Copyright David Abrahams and Jeremy Siek 2003.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_ITERATOR_TESTS_HPP
+# define BOOST_ITERATOR_TESTS_HPP
+
+// This is meant to be the beginnings of a comprehensive, generic
+// test suite for STL concepts such as iterators and containers.
+//
+// Revision History:
+// 28 Apr 2002 Fixed input iterator requirements.
+// For a == b a++ == b++ is no longer required.
+// See 24.1.1/3 for details.
+// (Thomas Witt)
+// 08 Feb 2001 Fixed bidirectional iterator test so that
+// --i is no longer a precondition.
+// (Jeremy Siek)
+// 04 Feb 2001 Added lvalue test, corrected preconditions
+// (David Abrahams)
+
+# include <iterator>
+# include <boost/static_assert.hpp>
+# include <boost/concept_archetype.hpp> // for detail::dummy_constructor
+# include <boost/implicit_cast.hpp>
+# include <boost/core/ignore_unused.hpp>
+# include <boost/core/lightweight_test.hpp>
+# include <boost/type_traits/is_same.hpp>
+# include <boost/type_traits/is_pointer.hpp>
+# include <boost/type_traits/is_reference.hpp>
+
+namespace boost {
+
+ // use this for the value type
+struct dummyT {
+ dummyT() { }
+ dummyT(detail::dummy_constructor) { }
+ dummyT(int x) : m_x(x) { }
+ int foo() const { return m_x; }
+ bool operator==(const dummyT& d) const { return m_x == d.m_x; }
+ int m_x;
+};
+
+}
+
+namespace boost {
+namespace iterators {
+
+// Tests whether type Iterator satisfies the requirements for a
+// TrivialIterator.
+// Preconditions: i != j, *i == val
+template <class Iterator, class T>
+void trivial_iterator_test(const Iterator i, const Iterator j, T val)
+{
+ Iterator k;
+ BOOST_TEST(i == i);
+ BOOST_TEST(j == j);
+ BOOST_TEST(i != j);
+#ifdef BOOST_NO_STD_ITERATOR_TRAITS
+ T v = *i;
+#else
+ typename std::iterator_traits<Iterator>::value_type v = *i;
+#endif
+ BOOST_TEST(v == val);
+ boost::ignore_unused(v);
+#if 0
+ // hmm, this will give a warning for transform_iterator... perhaps
+ // this should be separated out into a stand-alone test since there
+ // are several situations where it can't be used, like for
+ // integer_range::iterator.
+ BOOST_TEST(v == i->foo());
+#endif
+ k = i;
+ BOOST_TEST(k == k);
+ BOOST_TEST(k == i);
+ BOOST_TEST(k != j);
+ BOOST_TEST(*k == val);
+ boost::ignore_unused(k);
+}
+
+
+// Preconditions: i != j
+template <class Iterator, class T>
+void mutable_trivial_iterator_test(const Iterator i, const Iterator j, T val)
+{
+ *i = val;
+ trivial_iterator_test(i, j, val);
+}
+
+
+// Preconditions: *i == v1, *++i == v2
+template <class Iterator, class T>
+void input_iterator_test(Iterator i, T v1, T v2)
+{
+ Iterator i1(i);
+
+ BOOST_TEST(i == i1);
+ BOOST_TEST(!(i != i1));
+
+ // I can see no generic way to create an input iterator
+ // that is in the domain of== of i and != i.
+ // The following works for istream_iterator but is not
+ // guaranteed to work for arbitrary input iterators.
+ //
+ // Iterator i2;
+ //
+ // BOOST_TEST(i != i2);
+ // BOOST_TEST(!(i == i2));
+
+ BOOST_TEST(*i1 == v1);
+ BOOST_TEST(*i == v1);
+
+ // we cannot test for equivalence of (void)++i & (void)i++
+ // as i is only guaranteed to be single pass.
+ BOOST_TEST(*i++ == v1);
+ boost::ignore_unused(i1);
+
+ i1 = i;
+
+ BOOST_TEST(i == i1);
+ BOOST_TEST(!(i != i1));
+
+ BOOST_TEST(*i1 == v2);
+ BOOST_TEST(*i == v2);
+ boost::ignore_unused(i1);
+
+ // i is dereferencable, so it must be incrementable.
+ ++i;
+
+ // how to test for operator-> ?
+}
+
+// how to test output iterator?
+
+
+template <bool is_pointer> struct lvalue_test
+{
+ template <class Iterator> static void check(Iterator)
+ {
+# ifndef BOOST_NO_STD_ITERATOR_TRAITS
+ typedef typename std::iterator_traits<Iterator>::reference reference;
+ typedef typename std::iterator_traits<Iterator>::value_type value_type;
+# else
+ typedef typename Iterator::reference reference;
+ typedef typename Iterator::value_type value_type;
+# endif
+ BOOST_STATIC_ASSERT(boost::is_reference<reference>::value);
+ BOOST_STATIC_ASSERT((boost::is_same<reference,value_type&>::value
+ || boost::is_same<reference,const value_type&>::value
+ ));
+ }
+};
+
+# ifdef BOOST_NO_STD_ITERATOR_TRAITS
+template <> struct lvalue_test<true> {
+ template <class T> static void check(T) {}
+};
+#endif
+
+template <class Iterator, class T>
+void forward_iterator_test(Iterator i, T v1, T v2)
+{
+ input_iterator_test(i, v1, v2);
+
+ Iterator i1 = i, i2 = i;
+
+ BOOST_TEST(i == i1++);
+ BOOST_TEST(i != ++i2);
+
+ trivial_iterator_test(i, i1, v1);
+ trivial_iterator_test(i, i2, v1);
+
+ ++i;
+ BOOST_TEST(i == i1);
+ BOOST_TEST(i == i2);
+ ++i1;
+ ++i2;
+
+ trivial_iterator_test(i, i1, v2);
+ trivial_iterator_test(i, i2, v2);
+
+ // borland doesn't allow non-type template parameters
+# if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
+ lvalue_test<(boost::is_pointer<Iterator>::value)>::check(i);
+#endif
+}
+
+// Preconditions: *i == v1, *++i == v2
+template <class Iterator, class T>
+void bidirectional_iterator_test(Iterator i, T v1, T v2)
+{
+ forward_iterator_test(i, v1, v2);
+ ++i;
+
+ Iterator i1 = i, i2 = i;
+
+ BOOST_TEST(i == i1--);
+ BOOST_TEST(i != --i2);
+
+ trivial_iterator_test(i, i1, v2);
+ trivial_iterator_test(i, i2, v2);
+
+ --i;
+ BOOST_TEST(i == i1);
+ BOOST_TEST(i == i2);
+ ++i1;
+ ++i2;
+
+ trivial_iterator_test(i, i1, v1);
+ trivial_iterator_test(i, i2, v1);
+}
+
+// mutable_bidirectional_iterator_test
+
+template <class U> struct undefined;
+
+// Preconditions: [i,i+N) is a valid range
+template <class Iterator, class TrueVals>
+void random_access_iterator_test(Iterator i, int N, TrueVals vals)
+{
+ bidirectional_iterator_test(i, vals[0], vals[1]);
+ const Iterator j = i;
+ int c;
+
+ typedef typename std::iterator_traits<Iterator>::value_type value_type;
+ boost::ignore_unused<value_type>();
+
+ for (c = 0; c < N-1; ++c) {
+ BOOST_TEST(i == j + c);
+ BOOST_TEST(*i == vals[c]);
+ BOOST_TEST(*i == boost::implicit_cast<value_type>(j[c]));
+ BOOST_TEST(*i == *(j + c));
+ BOOST_TEST(*i == *(c + j));
+ ++i;
+ BOOST_TEST(i > j);
+ BOOST_TEST(i >= j);
+ BOOST_TEST(j <= i);
+ BOOST_TEST(j < i);
+ }
+
+ Iterator k = j + N - 1;
+ for (c = 0; c < N-1; ++c) {
+ BOOST_TEST(i == k - c);
+ BOOST_TEST(*i == vals[N - 1 - c]);
+ BOOST_TEST(*i == boost::implicit_cast<value_type>(j[N - 1 - c]));
+ Iterator q = k - c;
+ boost::ignore_unused(q);
+ BOOST_TEST(*i == *q);
+ BOOST_TEST(i > j);
+ BOOST_TEST(i >= j);
+ BOOST_TEST(j <= i);
+ BOOST_TEST(j < i);
+ --i;
+ }
+}
+
+// Precondition: i != j
+template <class Iterator, class ConstIterator>
+void const_nonconst_iterator_test(Iterator i, ConstIterator j)
+{
+ BOOST_TEST(i != j);
+ BOOST_TEST(j != i);
+
+ ConstIterator k(i);
+ BOOST_TEST(k == i);
+ BOOST_TEST(i == k);
+
+ k = i;
+ BOOST_TEST(k == i);
+ BOOST_TEST(i == k);
+ boost::ignore_unused(k);
+}
+
+} // namespace iterators
+
+using iterators::undefined;
+using iterators::trivial_iterator_test;
+using iterators::mutable_trivial_iterator_test;
+using iterators::input_iterator_test;
+using iterators::lvalue_test;
+using iterators::forward_iterator_test;
+using iterators::bidirectional_iterator_test;
+using iterators::random_access_iterator_test;
+using iterators::const_nonconst_iterator_test;
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_TESTS_HPP
diff --git a/include/boost/pointee.hpp b/include/boost/pointee.hpp
new file mode 100644
index 0000000..f3bcf44
--- /dev/null
+++ b/include/boost/pointee.hpp
@@ -0,0 +1,76 @@
+#ifndef POINTEE_DWA200415_HPP
+# define POINTEE_DWA200415_HPP
+
+//
+// Copyright David Abrahams 2004. Use, modification and distribution is
+// subject to the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// typename pointee<P>::type provides the pointee type of P.
+//
+// For example, it is T for T* and X for shared_ptr<X>.
+//
+// http://www.boost.org/libs/iterator/doc/pointee.html
+//
+
+# include <boost/detail/is_incrementable.hpp>
+# include <boost/iterator/iterator_traits.hpp>
+# include <boost/type_traits/add_const.hpp>
+# include <boost/type_traits/remove_cv.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/mpl/eval_if.hpp>
+
+#include <iterator>
+
+namespace boost {
+
+namespace detail
+{
+ template <class P>
+ struct smart_ptr_pointee
+ {
+ typedef typename P::element_type type;
+ };
+
+ template <class Iterator>
+ struct iterator_pointee
+ {
+ typedef typename std::iterator_traits<Iterator>::value_type value_type;
+
+ struct impl
+ {
+ template <class T>
+ static char test(T const&);
+
+ static char (& test(value_type&) )[2];
+
+ static Iterator& x;
+ };
+
+ BOOST_STATIC_CONSTANT(bool, is_constant = sizeof(impl::test(*impl::x)) == 1);
+
+ typedef typename mpl::if_c<
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+ ::boost::detail::iterator_pointee<Iterator>::is_constant
+# else
+ is_constant
+# endif
+ , typename add_const<value_type>::type
+ , value_type
+ >::type type;
+ };
+}
+
+template <class P>
+struct pointee
+ : mpl::eval_if<
+ detail::is_incrementable<P>
+ , detail::iterator_pointee<P>
+ , detail::smart_ptr_pointee<P>
+ >
+{
+};
+
+} // namespace boost
+
+#endif // POINTEE_DWA200415_HPP
diff --git a/include/boost/shared_container_iterator.hpp b/include/boost/shared_container_iterator.hpp
new file mode 100644
index 0000000..e803bd6
--- /dev/null
+++ b/include/boost/shared_container_iterator.hpp
@@ -0,0 +1,69 @@
+// (C) Copyright Ronald Garcia 2002. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// See http://www.boost.org/libs/utility/shared_container_iterator.html for documentation.
+
+#ifndef SHARED_CONTAINER_ITERATOR_RG08102002_HPP
+#define SHARED_CONTAINER_ITERATOR_RG08102002_HPP
+
+#include "boost/iterator_adaptors.hpp"
+#include "boost/shared_ptr.hpp"
+#include <utility>
+
+namespace boost {
+namespace iterators {
+
+template <typename Container>
+class shared_container_iterator : public iterator_adaptor<
+ shared_container_iterator<Container>,
+ typename Container::iterator> {
+
+ typedef iterator_adaptor<
+ shared_container_iterator<Container>,
+ typename Container::iterator> super_t;
+
+ typedef typename Container::iterator iterator_t;
+ typedef boost::shared_ptr<Container> container_ref_t;
+
+ container_ref_t container_ref;
+public:
+ shared_container_iterator() { }
+
+ shared_container_iterator(iterator_t const& x,container_ref_t const& c) :
+ super_t(x), container_ref(c) { }
+
+
+};
+
+template <typename Container>
+inline shared_container_iterator<Container>
+make_shared_container_iterator(typename Container::iterator iter,
+ boost::shared_ptr<Container> const& container) {
+ typedef shared_container_iterator<Container> iterator;
+ return iterator(iter,container);
+}
+
+
+
+template <typename Container>
+inline std::pair<
+ shared_container_iterator<Container>,
+ shared_container_iterator<Container> >
+make_shared_container_range(boost::shared_ptr<Container> const& container) {
+ return
+ std::make_pair(
+ make_shared_container_iterator(container->begin(),container),
+ make_shared_container_iterator(container->end(),container));
+}
+
+} // namespace iterators
+
+using iterators::shared_container_iterator;
+using iterators::make_shared_container_iterator;
+using iterators::make_shared_container_range;
+
+} // namespace boost
+
+#endif // SHARED_CONTAINER_ITERATOR_RG08102002_HPP