-// (C) Copyright Jeremy Siek 2002.\r
-// Distributed under the Boost Software License, Version 1.0. (See\r
-// accompanying file LICENSE_1_0.txt or copy at\r
-// http://www.boost.org/LICENSE_1_0.txt)\r
-\r
-#ifndef BOOST_ITERATOR_ARCHETYPES_HPP\r
-#define BOOST_ITERATOR_ARCHETYPES_HPP\r
-\r
-#include <boost/iterator/iterator_categories.hpp>\r
-#include <boost/operators.hpp>\r
-#include <boost/static_assert.hpp>\r
-#include <boost/iterator.hpp>\r
-\r
-#include <boost/iterator/detail/facade_iterator_category.hpp>\r
-\r
-#include <boost/type_traits/is_const.hpp>\r
-#include <boost/type_traits/add_const.hpp>\r
-#include <boost/type_traits/remove_const.hpp>\r
-#include <boost/type_traits/remove_cv.hpp>\r
-\r
-#include <boost/concept_archetype.hpp>\r
-\r
-#include <boost/mpl/aux_/msvc_eti_base.hpp>\r
-#include <boost/mpl/bitand.hpp>\r
-#include <boost/mpl/int.hpp>\r
-#include <boost/mpl/equal_to.hpp>\r
-#include <boost/mpl/if.hpp>\r
-#include <boost/mpl/eval_if.hpp>\r
-#include <boost/mpl/and.hpp>\r
-#include <boost/mpl/identity.hpp>\r
-\r
-#include <cstddef>\r
-\r
-namespace boost {\r
-\r
-template <class Value, class AccessCategory>\r
-struct access_archetype;\r
-\r
-template <class Derived, class Value, class AccessCategory, class TraversalCategory>\r
-struct traversal_archetype;\r
-\r
-namespace iterator_archetypes\r
-{\r
- enum {\r
- readable_iterator_bit = 1\r
- , writable_iterator_bit = 2\r
- , swappable_iterator_bit = 4\r
- , lvalue_iterator_bit = 8\r
- };\r
-\r
- // Not quite tags, since dispatching wouldn't work.\r
- typedef mpl::int_<readable_iterator_bit>::type readable_iterator_t;\r
- typedef mpl::int_<writable_iterator_bit>::type writable_iterator_t;\r
- \r
- typedef mpl::int_<\r
- (readable_iterator_bit|writable_iterator_bit)\r
- >::type readable_writable_iterator_t;\r
- \r
- typedef mpl::int_<\r
- (readable_iterator_bit|lvalue_iterator_bit)\r
- >::type readable_lvalue_iterator_t;\r
- \r
- typedef mpl::int_<\r
- (lvalue_iterator_bit|writable_iterator_bit)\r
- >::type writable_lvalue_iterator_t;\r
- \r
- typedef mpl::int_<swappable_iterator_bit>::type swappable_iterator_t;\r
- typedef mpl::int_<lvalue_iterator_bit>::type lvalue_iterator_t;\r
-\r
- template <class Derived, class Base>\r
- struct has_access\r
- : mpl::equal_to<\r
- mpl::bitand_<Derived,Base>\r
- , Base\r
- >\r
- {};\r
-}\r
-\r
-namespace detail\r
-{\r
- template <class T>\r
- struct assign_proxy\r
- {\r
- assign_proxy& operator=(T) { return *this; }\r
- };\r
-\r
- template <class T>\r
- struct read_proxy\r
- {\r
- operator T() { return static_object<T>::get(); }\r
- };\r
-\r
- template <class T>\r
- struct read_write_proxy\r
- : read_proxy<T> // Use to inherit from assign_proxy, but that doesn't work. -JGS\r
- {\r
- read_write_proxy& operator=(T) { return *this; }\r
- };\r
-\r
- template <class T>\r
- struct arrow_proxy\r
- {\r
- T const* operator->() const { return 0; }\r
- };\r
-\r
- struct no_operator_brackets {};\r
-\r
- template <class ValueType>\r
- struct readable_operator_brackets\r
- {\r
- read_proxy<ValueType> operator[](std::ptrdiff_t n) const { return read_proxy<ValueType>(); }\r
- };\r
-\r
- template <class ValueType>\r
- struct writable_operator_brackets\r
- {\r
- read_write_proxy<ValueType> operator[](std::ptrdiff_t n) const { return read_write_proxy<ValueType>(); }\r
- };\r
-\r
- template <class Value, class AccessCategory, class TraversalCategory>\r
- struct operator_brackets\r
- : mpl::aux::msvc_eti_base<\r
- typename mpl::eval_if<\r
- is_convertible<TraversalCategory, random_access_traversal_tag>\r
- , mpl::eval_if<\r
- iterator_archetypes::has_access<\r
- AccessCategory\r
- , iterator_archetypes::writable_iterator_t\r
- >\r
- , mpl::identity<writable_operator_brackets<Value> >\r
- , mpl::if_<\r
- iterator_archetypes::has_access<\r
- AccessCategory\r
- , iterator_archetypes::readable_iterator_t\r
- >\r
- , readable_operator_brackets<Value>\r
- , no_operator_brackets\r
- >\r
- >\r
- , mpl::identity<no_operator_brackets>\r
- >::type\r
- >::type\r
- {};\r
- \r
- template <class TraversalCategory>\r
- struct traversal_archetype_impl\r
- {\r
- template <class Derived,class Value> struct archetype;\r
- };\r
-\r
- // Constructor argument for those iterators that\r
- // are not default constructible\r
- struct ctor_arg {};\r
-\r
- template <class Derived, class Value, class TraversalCategory>\r
- struct traversal_archetype_\r
- : mpl::aux::msvc_eti_base<\r
- typename traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>\r
- >::type\r
- {\r
- typedef typename\r
- traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>\r
- base;\r
- \r
- traversal_archetype_() {}\r
-\r
- traversal_archetype_(ctor_arg arg)\r
- : base(arg) \r
- {}\r
- };\r
-\r
- template <>\r
- struct traversal_archetype_impl<incrementable_traversal_tag>\r
- {\r
- template<class Derived, class Value>\r
- struct archetype\r
- {\r
- explicit archetype(ctor_arg) {}\r
-\r
- struct bogus { }; // This use to be void, but that causes trouble for iterator_facade. Need more research. -JGS\r
- typedef bogus difference_type;\r
-\r
- Derived& operator++() { return (Derived&)static_object<Derived>::get(); }\r
- Derived operator++(int) const { return (Derived&)static_object<Derived>::get(); }\r
- };\r
- };\r
-\r
- template <>\r
- struct traversal_archetype_impl<single_pass_traversal_tag>\r
- {\r
- template<class Derived, class Value>\r
- struct archetype\r
- : public equality_comparable< traversal_archetype_<Derived, Value, single_pass_traversal_tag> >,\r
- public traversal_archetype_<Derived, Value, incrementable_traversal_tag>\r
- {\r
- explicit archetype(ctor_arg arg)\r
- : traversal_archetype_<Derived, Value, incrementable_traversal_tag>(arg)\r
- {}\r
- \r
- typedef std::ptrdiff_t difference_type;\r
- };\r
- };\r
-\r
- template <class Derived, class Value>\r
- bool operator==(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&,\r
- traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&) { return true; }\r
- \r
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)\r
- // doesn't seem to pick up != from equality_comparable\r
- template <class Derived, class Value>\r
- bool operator!=(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&,\r
- traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&) { return true; }\r
-#endif \r
- template <>\r
- struct traversal_archetype_impl<forward_traversal_tag>\r
- {\r
- template<class Derived, class Value>\r
- struct archetype\r
- : public traversal_archetype_<Derived, Value, single_pass_traversal_tag>\r
- {\r
- archetype() \r
- : traversal_archetype_<Derived, Value, single_pass_traversal_tag>(ctor_arg())\r
- {}\r
- };\r
- };\r
-\r
- template <>\r
- struct traversal_archetype_impl<bidirectional_traversal_tag>\r
- {\r
- template<class Derived, class Value>\r
- struct archetype\r
- : public traversal_archetype_<Derived, Value, forward_traversal_tag>\r
- {\r
- Derived& operator--() { return static_object<Derived>::get(); }\r
- Derived operator--(int) const { return static_object<Derived>::get(); }\r
- };\r
- };\r
-\r
- template <>\r
- struct traversal_archetype_impl<random_access_traversal_tag>\r
- {\r
- template<class Derived, class Value>\r
- struct archetype\r
- : public traversal_archetype_<Derived, Value, bidirectional_traversal_tag> \r
- {\r
- Derived& operator+=(std::ptrdiff_t) { return static_object<Derived>::get(); }\r
- Derived& operator-=(std::ptrdiff_t) { return static_object<Derived>::get(); }\r
- };\r
- };\r
-\r
- template <class Derived, class Value>\r
- Derived& operator+(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,\r
- std::ptrdiff_t) { return static_object<Derived>::get(); }\r
-\r
- template <class Derived, class Value>\r
- Derived& operator+(std::ptrdiff_t,\r
- traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)\r
- { return static_object<Derived>::get(); }\r
-\r
- template <class Derived, class Value>\r
- Derived& operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,\r
- std::ptrdiff_t)\r
- { return static_object<Derived>::get(); }\r
-\r
- template <class Derived, class Value>\r
- std::ptrdiff_t operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,\r
- traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)\r
- { return 0; }\r
-\r
- template <class Derived, class Value>\r
- bool operator<(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,\r
- traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)\r
- { return true; }\r
-\r
- template <class Derived, class Value>\r
- bool operator>(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,\r
- traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)\r
- { return true; }\r
-\r
- template <class Derived, class Value>\r
- bool operator<=(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,\r
- traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)\r
- { return true; }\r
-\r
- template <class Derived, class Value>\r
- bool operator>=(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,\r
- traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)\r
- { return true; }\r
-\r
- struct bogus_type;\r
-\r
- template <class Value>\r
- struct convertible_type\r
- : mpl::if_< is_const<Value>,\r
- typename remove_const<Value>::type,\r
- bogus_type >\r
- {};\r
-\r
-} // namespace detail\r
-\r
-\r
-template <class> struct undefined;\r
- \r
-template <class AccessCategory>\r
-struct iterator_access_archetype_impl\r
-{\r
- template <class Value> struct archetype;\r
-};\r
-\r
-template <class Value, class AccessCategory>\r
-struct iterator_access_archetype\r
- : mpl::aux::msvc_eti_base<\r
- typename iterator_access_archetype_impl<\r
- AccessCategory\r
- >::template archetype<Value>\r
- >::type\r
-{\r
-};\r
-\r
-template <>\r
-struct iterator_access_archetype_impl<\r
- iterator_archetypes::readable_iterator_t\r
->\r
-{\r
- template <class Value>\r
- struct archetype\r
- {\r
- typedef typename remove_cv<Value>::type value_type;\r
- typedef Value reference;\r
- typedef Value* pointer;\r
-\r
- value_type operator*() const { return static_object<value_type>::get(); }\r
-\r
- detail::arrow_proxy<Value> operator->() const { return detail::arrow_proxy<Value>(); }\r
- };\r
-};\r
-\r
-template <>\r
-struct iterator_access_archetype_impl<\r
- iterator_archetypes::writable_iterator_t\r
->\r
-{\r
- template <class Value>\r
- struct archetype\r
- {\r
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)\r
- BOOST_STATIC_ASSERT(!is_const<Value>::value);\r
-# endif \r
- typedef void value_type;\r
- typedef void reference;\r
- typedef void pointer;\r
-\r
- detail::assign_proxy<Value> operator*() const { return detail::assign_proxy<Value>(); }\r
- };\r
-};\r
-\r
-template <>\r
-struct iterator_access_archetype_impl<\r
- iterator_archetypes::readable_writable_iterator_t\r
->\r
-{\r
- template <class Value>\r
- struct archetype\r
- : public virtual iterator_access_archetype<\r
- Value, iterator_archetypes::readable_iterator_t\r
- >\r
- {\r
- typedef detail::read_write_proxy<Value> reference;\r
-\r
- detail::read_write_proxy<Value> operator*() const { return detail::read_write_proxy<Value>(); }\r
- };\r
-};\r
-\r
-template <>\r
-struct iterator_access_archetype_impl<iterator_archetypes::readable_lvalue_iterator_t>\r
-{\r
- template <class Value>\r
- struct archetype\r
- : public virtual iterator_access_archetype<\r
- Value, iterator_archetypes::readable_iterator_t\r
- >\r
- {\r
- typedef Value& reference;\r
-\r
- Value& operator*() const { return static_object<Value>::get(); }\r
- Value* operator->() const { return 0; }\r
- };\r
-};\r
- \r
-template <>\r
-struct iterator_access_archetype_impl<iterator_archetypes::writable_lvalue_iterator_t>\r
-{\r
- template <class Value>\r
- struct archetype\r
- : public virtual iterator_access_archetype<\r
- Value, iterator_archetypes::readable_lvalue_iterator_t\r
- >\r
- {\r
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)\r
- BOOST_STATIC_ASSERT((!is_const<Value>::value));\r
-# endif \r
- };\r
-};\r
- \r
-\r
-template <class Value, class AccessCategory, class TraversalCategory>\r
-struct iterator_archetype;\r
- \r
-template <class Value, class AccessCategory, class TraversalCategory>\r
-struct traversal_archetype_base \r
- : detail::operator_brackets<\r
- typename remove_cv<Value>::type\r
- , AccessCategory\r
- , TraversalCategory\r
- >\r
- , detail::traversal_archetype_<\r
- iterator_archetype<Value, AccessCategory, TraversalCategory>\r
- , Value\r
- , TraversalCategory\r
- >\r
-{\r
-};\r
-\r
-namespace detail\r
-{\r
- template <class Value, class AccessCategory, class TraversalCategory>\r
- struct iterator_archetype_base\r
- : iterator_access_archetype<Value, AccessCategory>\r
- , traversal_archetype_base<Value, AccessCategory, TraversalCategory>\r
- {\r
- typedef iterator_access_archetype<Value, AccessCategory> access;\r
- \r
- typedef typename detail::facade_iterator_category<\r
- TraversalCategory\r
- , typename mpl::eval_if<\r
- iterator_archetypes::has_access<\r
- AccessCategory, iterator_archetypes::writable_iterator_t\r
- >\r
- , remove_const<Value>\r
- , add_const<Value>\r
- >::type\r
- , typename access::reference\r
- >::type iterator_category;\r
-\r
- // Needed for some broken libraries (see below)\r
- typedef boost::iterator<\r
- iterator_category\r
- , Value\r
- , typename traversal_archetype_base<\r
- Value, AccessCategory, TraversalCategory\r
- >::difference_type\r
- , typename access::pointer\r
- , typename access::reference\r
- > workaround_iterator_base;\r
- };\r
-}\r
-\r
-template <class Value, class AccessCategory, class TraversalCategory>\r
-struct iterator_archetype\r
- : public detail::iterator_archetype_base<Value, AccessCategory, TraversalCategory>\r
-\r
- // These broken libraries require derivation from std::iterator\r
- // (or related magic) in order to handle iter_swap and other\r
- // iterator operations\r
-# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, < 310) \\r
- || BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(0x20101))\r
- , public detail::iterator_archetype_base<\r
- Value, AccessCategory, TraversalCategory\r
- >::workaround_iterator_base\r
-# endif \r
-{\r
- // Derivation from std::iterator above caused references to nested\r
- // types to be ambiguous, so now we have to redeclare them all\r
- // here.\r
-# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, < 310) \\r
- || BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(0x20101))\r
- \r
- typedef detail::iterator_archetype_base<\r
- Value,AccessCategory,TraversalCategory\r
- > base;\r
- \r
- typedef typename base::value_type value_type;\r
- typedef typename base::reference reference;\r
- typedef typename base::pointer pointer;\r
- typedef typename base::difference_type difference_type;\r
- typedef typename base::iterator_category iterator_category;\r
-# endif\r
-\r
- iterator_archetype() { }\r
- iterator_archetype(iterator_archetype const& x)\r
- : detail::iterator_archetype_base<\r
- Value\r
- , AccessCategory\r
- , TraversalCategory\r
- >(x)\r
- {}\r
-\r
- iterator_archetype& operator=(iterator_archetype const&)\r
- { return *this; }\r
-\r
-# if 0\r
- // Optional conversion from mutable\r
- iterator_archetype(\r
- iterator_archetype<\r
- typename detail::convertible_type<Value>::type\r
- , AccessCategory\r
- , TraversalCategory> const&\r
- );\r
-# endif\r
-};\r
-\r
-} // namespace boost\r
-\r
-\r
-#endif // BOOST_ITERATOR_ARCHETYPES_HPP\r
+// (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.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/aux_/msvc_eti_base.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 {
+
+template <class Value, class AccessCategory>
+struct access_archetype;
+
+template <class Derived, class Value, class AccessCategory, class TraversalCategory>
+struct traversal_archetype;
+
+namespace iterator_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::aux::msvc_eti_base<
+ typename mpl::eval_if<
+ is_convertible<TraversalCategory, random_access_traversal_tag>
+ , mpl::eval_if<
+ iterator_archetypes::has_access<
+ AccessCategory
+ , iterator_archetypes::writable_iterator_t
+ >
+ , mpl::identity<writable_operator_brackets<Value> >
+ , mpl::if_<
+ iterator_archetypes::has_access<
+ AccessCategory
+ , iterator_archetypes::readable_iterator_t
+ >
+ , readable_operator_brackets<Value>
+ , no_operator_brackets
+ >
+ >
+ , mpl::identity<no_operator_brackets>
+ >::type
+ >::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_
+ : mpl::aux::msvc_eti_base<
+ typename traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
+ >::type
+ {
+ 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; }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+ // doesn't seem to pick up != from equality_comparable
+ 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; }
+#endif
+ 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
+ : mpl::aux::msvc_eti_base<
+ typename iterator_access_archetype_impl<
+ AccessCategory
+ >::template archetype<Value>
+ >::type
+{
+};
+
+template <>
+struct iterator_access_archetype_impl<
+ iterator_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<
+ iterator_archetypes::writable_iterator_t
+>
+{
+ template <class Value>
+ struct archetype
+ {
+# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+ BOOST_STATIC_ASSERT(!is_const<Value>::value);
+# endif
+ 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<
+ iterator_archetypes::readable_writable_iterator_t
+>
+{
+ template <class Value>
+ struct archetype
+ : public virtual iterator_access_archetype<
+ Value, iterator_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<iterator_archetypes::readable_lvalue_iterator_t>
+{
+ template <class Value>
+ struct archetype
+ : public virtual iterator_access_archetype<
+ Value, iterator_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<iterator_archetypes::writable_lvalue_iterator_t>
+{
+ template <class Value>
+ struct archetype
+ : public virtual iterator_access_archetype<
+ Value, iterator_archetypes::readable_lvalue_iterator_t
+ >
+ {
+# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+ BOOST_STATIC_ASSERT((!is_const<Value>::value));
+# endif
+ };
+};
+
+
+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<
+ iterator_archetypes::has_access<
+ AccessCategory, iterator_archetypes::writable_iterator_t
+ >
+ , remove_const<Value>
+ , add_const<Value>
+ >::type
+ , typename access::reference
+ >::type iterator_category;
+
+ // Needed for some broken libraries (see below)
+ typedef boost::iterator<
+ iterator_category
+ , Value
+ , typename traversal_archetype_base<
+ Value, AccessCategory, TraversalCategory
+ >::difference_type
+ , typename access::pointer
+ , typename access::reference
+ > workaround_iterator_base;
+ };
+}
+
+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 boost
+
+
+#endif // BOOST_ITERATOR_ARCHETYPES_HPP
projects / lyx.git / blobdiff