diff options
Diffstat (limited to 'cutl/details/boost/iterator')
| -rw-r--r-- | cutl/details/boost/iterator/detail/config_def.hpp | 137 | ||||
| -rw-r--r-- | cutl/details/boost/iterator/detail/config_undef.hpp | 25 | ||||
| -rw-r--r-- | cutl/details/boost/iterator/detail/enable_if.hpp | 86 | ||||
| -rw-r--r-- | cutl/details/boost/iterator/detail/facade_iterator_category.hpp | 200 | ||||
| -rw-r--r-- | cutl/details/boost/iterator/interoperable.hpp | 50 | ||||
| -rw-r--r-- | cutl/details/boost/iterator/iterator_categories.hpp | 188 | ||||
| -rw-r--r-- | cutl/details/boost/iterator/iterator_facade.hpp | 874 | ||||
| -rw-r--r-- | cutl/details/boost/iterator/iterator_traits.hpp | 92 |
8 files changed, 0 insertions, 1652 deletions
diff --git a/cutl/details/boost/iterator/detail/config_def.hpp b/cutl/details/boost/iterator/detail/config_def.hpp deleted file mode 100644 index 0b36397..0000000 --- a/cutl/details/boost/iterator/detail/config_def.hpp +++ /dev/null @@ -1,137 +0,0 @@ -// (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 <cutl/details/boost/config.hpp> // for prior -#include <cutl/details/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(BOOST_MSVC, <= 1300) \ - || 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__, == 2) \ - || 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 <cutl/details/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 = cutl_details_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(BOOST_MSVC, <= 1300) -# define BOOST_ARG_DEPENDENT_TYPENAME typename -# else -# define BOOST_ARG_DEPENDENT_TYPENAME -# endif - -# if BOOST_WORKAROUND(__GNUC__, == 2) && BOOST_WORKAROUND(__GNUC_MINOR__, BOOST_TESTED_AT(95)) \ - || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - -// GCC-2.95 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/cutl/details/boost/iterator/detail/config_undef.hpp b/cutl/details/boost/iterator/detail/config_undef.hpp deleted file mode 100644 index 9dcd1d5..0000000 --- a/cutl/details/boost/iterator/detail/config_undef.hpp +++ /dev/null @@ -1,25 +0,0 @@ -// (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_ARG_DEPENDENT_TYPENAME -#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/cutl/details/boost/iterator/detail/enable_if.hpp b/cutl/details/boost/iterator/detail/enable_if.hpp deleted file mode 100644 index 23f67ef..0000000 --- a/cutl/details/boost/iterator/detail/enable_if.hpp +++ /dev/null @@ -1,86 +0,0 @@ -// (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 <cutl/details/boost/detail/workaround.hpp> -#include <cutl/details/boost/mpl/identity.hpp> - -#include <cutl/details/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 cutl_details_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 - { -# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - typedef Return type; -# endif - }; - - } // namespace iterators - -} // namespace cutl_details_boost - -#include <cutl/details/boost/iterator/detail/config_undef.hpp> - -#endif // BOOST_ENABLE_IF_23022003THW_HPP diff --git a/cutl/details/boost/iterator/detail/facade_iterator_category.hpp b/cutl/details/boost/iterator/detail/facade_iterator_category.hpp deleted file mode 100644 index 6bdd37a..0000000 --- a/cutl/details/boost/iterator/detail/facade_iterator_category.hpp +++ /dev/null @@ -1,200 +0,0 @@ -// 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 <cutl/details/boost/iterator/iterator_categories.hpp> - -# include <cutl/details/boost/mpl/or.hpp> // used in iterator_tag inheritance logic -# include <cutl/details/boost/mpl/and.hpp> -# include <cutl/details/boost/mpl/if.hpp> -# include <cutl/details/boost/mpl/eval_if.hpp> -# include <cutl/details/boost/mpl/identity.hpp> -# include <cutl/details/boost/mpl/assert.hpp> - -# include <cutl/details/boost/type_traits/is_same.hpp> -# include <cutl/details/boost/type_traits/is_const.hpp> -# include <cutl/details/boost/type_traits/is_reference.hpp> -# include <cutl/details/boost/type_traits/is_convertible.hpp> - -# include <cutl/details/boost/type_traits/is_same.hpp> - -# include <cutl/details/boost/iterator/detail/config_def.hpp> // try to keep this last - -# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY -# include <cutl/details/boost/detail/indirect_traits.hpp> -# endif - -// -// iterator_category deduction for iterator_facade -// - -// forward declaration -namespace cutl_details_boost { struct use_default; } - -namespace cutl_details_boost { 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> - , cutl_details_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. -// -// If writability has been disabled per the above metafunction, the -// result will not be convertible to output_iterator_tag. -// -// Otherwise, if Traversal == single_pass_traversal_tag, the following -// conditions will result in a tag that is convertible both to -// input_iterator_tag and output_iterator_tag: -// -// 1. Reference is a reference to non-const -// 2. Reference is not a reference and is convertible to Value -// -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 -{ -# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) - // 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 -# 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 -{ -# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) - BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>)); -# endif - - 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 cutl_details_boost::detail - -# include <cutl/details/boost/iterator/detail/config_undef.hpp> - -#endif // FACADE_ITERATOR_CATEGORY_DWA20031118_HPP diff --git a/cutl/details/boost/iterator/interoperable.hpp b/cutl/details/boost/iterator/interoperable.hpp deleted file mode 100644 index 1e76e21..0000000 --- a/cutl/details/boost/iterator/interoperable.hpp +++ /dev/null @@ -1,50 +0,0 @@ -// (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 <cutl/details/boost/mpl/bool.hpp> -# include <cutl/details/boost/mpl/or.hpp> - -# include <cutl/details/boost/type_traits/is_convertible.hpp> - -# include <cutl/details/boost/iterator/detail/config_def.hpp> // must appear last - -namespace cutl_details_boost -{ - - // - // 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 cutl_details_boost - -# include <cutl/details/boost/iterator/detail/config_undef.hpp> - -#endif // BOOST_INTEROPERABLE_23022003THW_HPP diff --git a/cutl/details/boost/iterator/iterator_categories.hpp b/cutl/details/boost/iterator/iterator_categories.hpp deleted file mode 100644 index cf22031..0000000 --- a/cutl/details/boost/iterator/iterator_categories.hpp +++ /dev/null @@ -1,188 +0,0 @@ -// (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 <cutl/details/boost/config.hpp> -# include <cutl/details/boost/detail/iterator.hpp> -# include <cutl/details/boost/iterator/detail/config_def.hpp> - -# include <cutl/details/boost/detail/workaround.hpp> - -# include <cutl/details/boost/mpl/eval_if.hpp> -# include <cutl/details/boost/mpl/identity.hpp> -# include <cutl/details/boost/mpl/placeholders.hpp> -# include <cutl/details/boost/mpl/aux_/lambda_support.hpp> - -# include <cutl/details/boost/type_traits/is_convertible.hpp> - -# include <cutl/details/boost/static_assert.hpp> - -namespace cutl_details_boost { - -// -// 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 - > - > - > - > - > - {}; - -# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template <> - struct old_category_to_traversal<int> - { - typedef int type; - }; -# endif - - 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 - > - > - > - > - > - { - }; - -# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template <> - struct pure_traversal_tag<int> - { - typedef int type; - }; -# endif - -} // 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> - , cutl_details_boost::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 cutl_details_boost::detail::iterator_traits<Iterator>::iterator_category - > -{}; - -# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT -// Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work -// out well. Instantiating the nested apply template also -// requires instantiating iterator_traits on the -// placeholder. Instead we just specialize it as a metafunction -// class. -template <> -struct iterator_traversal<mpl::_1> -{ - template <class T> - struct apply : iterator_traversal<T> - {}; -}; -template <> -struct iterator_traversal<mpl::_> - : iterator_traversal<mpl::_1> -{}; -# endif - -} // namespace cutl_details_boost - -#include <cutl/details/boost/iterator/detail/config_undef.hpp> - -#endif // BOOST_ITERATOR_CATEGORIES_HPP diff --git a/cutl/details/boost/iterator/iterator_facade.hpp b/cutl/details/boost/iterator/iterator_facade.hpp deleted file mode 100644 index 63858b5..0000000 --- a/cutl/details/boost/iterator/iterator_facade.hpp +++ /dev/null @@ -1,874 +0,0 @@ -// (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 <cutl/details/boost/iterator.hpp> -#include <cutl/details/boost/iterator/interoperable.hpp> -#include <cutl/details/boost/iterator/iterator_traits.hpp> - -#include <cutl/details/boost/iterator/detail/facade_iterator_category.hpp> -#include <cutl/details/boost/iterator/detail/enable_if.hpp> - -#include <cutl/details/boost/static_assert.hpp> -#include <cutl/details/boost/utility/addressof.hpp> - -#include <cutl/details/boost/type_traits/is_same.hpp> -#include <cutl/details/boost/type_traits/add_const.hpp> -#include <cutl/details/boost/type_traits/add_pointer.hpp> -#include <cutl/details/boost/type_traits/remove_const.hpp> -#include <cutl/details/boost/type_traits/remove_reference.hpp> -#include <cutl/details/boost/type_traits/is_convertible.hpp> -#include <cutl/details/boost/type_traits/is_pod.hpp> - -#include <cutl/details/boost/mpl/eval_if.hpp> -#include <cutl/details/boost/mpl/if.hpp> -#include <cutl/details/boost/mpl/or.hpp> -#include <cutl/details/boost/mpl/and.hpp> -#include <cutl/details/boost/mpl/not.hpp> -#include <cutl/details/boost/mpl/always.hpp> -#include <cutl/details/boost/mpl/apply.hpp> -#include <cutl/details/boost/mpl/identity.hpp> - -#include <cutl/details/boost/iterator/detail/config_def.hpp> // this goes last - -namespace cutl_details_boost -{ - // 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; - }; - }; - - // - // enable if for use in operator implementation. - // - template < - class Facade1 - , class Facade2 - , class Return - > - struct enable_if_interoperable -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) - { - typedef typename mpl::if_< - mpl::or_< - is_convertible<Facade1, Facade2> - , is_convertible<Facade2, Facade1> - > - , Return - , int[3] - >::type type; - }; -#else - : ::cutl_details_boost::iterators::enable_if< - mpl::or_< - is_convertible<Facade1, Facade2> - , is_convertible<Facade2, Facade1> - > - , Return - > - {}; -#endif - - // - // 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< - cutl_details_boost::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,Value const&> - - // 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 cutl_details_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 cutl_details_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 cutl_details_boost::addressof(x); - } - }; - -# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - // Deal with ETI - template<> - struct operator_arrow_dispatch<int, int> - { - typedef int result_type; - }; -# endif - - // 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. - cutl_details_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> -# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300) - mpl::if_< - is_convertible<I2,I1> - , typename I1::difference_type - , typename I2::difference_type - > -# else - mpl::eval_if< - is_convertible<I2,I1> - , iterator_difference<I1> - , iterator_difference<I2> - > -# endif - {}; - - }; - } // namespace detail - - - // Macros which describe the declarations of binary operators -# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY -# define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type) \ - 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(prefix, op, result_type) \ - template < \ - class Derived1, class V1, class TC1, class Reference1, class Difference1 \ - , class Derived2, class V2, class TC2, class Reference2, class Difference2 \ - > \ - prefix typename cutl_details_boost::detail::enable_if_interoperable< \ - 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_PLUS_HEAD(prefix,args) \ - template <class Derived, class V, class TC, class R, class D> \ - prefix Derived 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; - -# define BOOST_ITERATOR_FACADE_RELATION(op) \ - BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, cutl_details_boost::detail::always_bool2); - - BOOST_ITERATOR_FACADE_RELATION(==) - BOOST_ITERATOR_FACADE_RELATION(!=) - - BOOST_ITERATOR_FACADE_RELATION(<) - BOOST_ITERATOR_FACADE_RELATION(>) - BOOST_ITERATOR_FACADE_RELATION(<=) - BOOST_ITERATOR_FACADE_RELATION(>=) -# undef BOOST_ITERATOR_FACADE_RELATION - - BOOST_ITERATOR_FACADE_INTEROP_HEAD( - friend, -, cutl_details_boost::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); - } - - private: - // objects of this class are useless - iterator_core_access(); //undefined - }; - - // - // 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 -# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE - : public cutl_details_boost::detail::iterator_facade_types< - Value, CategoryOrTraversal, Reference, Difference - >::base -# undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE -# endif - { - private: - // - // Curiously Recurring Template interface. - // - Derived& derived() - { - return *static_cast<Derived*>(this); - } - - Derived const& derived() const - { - return *static_cast<Derived const*>(this); - } - - typedef cutl_details_boost::detail::iterator_facade_types< - Value, CategoryOrTraversal, Reference, Difference - > associated_types; - - typedef cutl_details_boost::detail::operator_arrow_dispatch< - Reference - , typename associated_types::pointer - > operator_arrow_dispatch_; - - protected: - // For use by derived classes - typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_; - - 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; - - reference operator*() const - { - return iterator_core_access::dereference(this->derived()); - } - - pointer operator->() const - { - return operator_arrow_dispatch_::apply(*this->derived()); - } - - typename cutl_details_boost::detail::operator_brackets_result<Derived,Value,reference>::type - operator[](difference_type n) const - { - typedef cutl_details_boost::detail::use_operator_brackets_proxy<Value,Reference> use_proxy; - - return cutl_details_boost::detail::make_operator_brackets_result<Derived>( - this->derived() + n - , use_proxy() - ); - } - - Derived& operator++() - { - iterator_core_access::increment(this->derived()); - return this->derived(); - } - -# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - typename cutl_details_boost::detail::postfix_increment_result<Derived,Value,Reference,CategoryOrTraversal>::type - operator++(int) - { - typename cutl_details_boost::detail::postfix_increment_result<Derived,Value,Reference,CategoryOrTraversal>::type - tmp(this->derived()); - ++*this; - return tmp; - } -# endif - - Derived& operator--() - { - iterator_core_access::decrement(this->derived()); - return this->derived(); - } - - Derived operator--(int) - { - Derived tmp(this->derived()); - --*this; - return tmp; - } - - 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; - } - -# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - // There appears to be a bug which trashes the data of classes - // derived from iterator_facade when they are assigned unless we - // define this assignment operator. This bug is only revealed - // (so far) in STLPort debug mode, but it's clearly a codegen - // problem so we apply the workaround for all MSVC6. - iterator_facade& operator=(iterator_facade const&) - { - return *this; - } -# endif - }; - -# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template <class I, class V, class TC, class R, class D> - inline typename cutl_details_boost::detail::postfix_increment_result<I,V,R,TC>::type - operator++( - iterator_facade<I,V,TC,R,D>& i - , int - ) - { - typename cutl_details_boost::detail::postfix_increment_result<I,V,R,TC>::type - tmp(*static_cast<I*>(&i)); - - ++i; - - return tmp; - } -# endif - - - // - // 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 cutl_details_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 \ - , cutl_details_boost::detail::always_bool2 \ - , return_prefix \ - , base_op \ - ) - - BOOST_ITERATOR_FACADE_RELATION(==, return, equal) - BOOST_ITERATOR_FACADE_RELATION(!=, return !, equal) - - BOOST_ITERATOR_FACADE_RELATION(<, return 0 >, distance_from) - BOOST_ITERATOR_FACADE_RELATION(>, return 0 <, distance_from) - BOOST_ITERATOR_FACADE_RELATION(<=, return 0 >=, distance_from) - BOOST_ITERATOR_FACADE_RELATION(>=, return 0 <=, distance_from) -# undef BOOST_ITERATOR_FACADE_RELATION - - // operator- requires an additional part in the static assertion - BOOST_ITERATOR_FACADE_INTEROP( - - - , cutl_details_boost::detail::choose_difference_type - , return - , distance_from - ) -# undef BOOST_ITERATOR_FACADE_INTEROP -# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD - -# 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 - -} // namespace cutl_details_boost - -#include <cutl/details/boost/iterator/detail/config_undef.hpp> - -#endif // BOOST_ITERATOR_FACADE_23022003THW_HPP diff --git a/cutl/details/boost/iterator/iterator_traits.hpp b/cutl/details/boost/iterator/iterator_traits.hpp deleted file mode 100644 index 449c91d..0000000 --- a/cutl/details/boost/iterator/iterator_traits.hpp +++ /dev/null @@ -1,92 +0,0 @@ -// 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 <cutl/details/boost/detail/iterator.hpp> -# include <cutl/details/boost/detail/workaround.hpp> - -namespace cutl_details_boost { - -// Unfortunately, g++ 2.95.x chokes when we define a class template -// iterator_category which has the same name as its -// std::iterator_category() function, probably due in part to the -// "std:: is visible globally" hack it uses. Use -// BOOST_ITERATOR_CATEGORY to write code that's portable to older -// GCCs. - -# if BOOST_WORKAROUND(__GNUC__, <= 2) -# define BOOST_ITERATOR_CATEGORY iterator_category_ -# else -# define BOOST_ITERATOR_CATEGORY iterator_category -# endif - - -template <class Iterator> -struct iterator_value -{ - typedef typename cutl_details_boost::detail::iterator_traits<Iterator>::value_type type; -}; - -template <class Iterator> -struct iterator_reference -{ - typedef typename cutl_details_boost::detail::iterator_traits<Iterator>::reference type; -}; - - -template <class Iterator> -struct iterator_pointer -{ - typedef typename cutl_details_boost::detail::iterator_traits<Iterator>::pointer type; -}; - -template <class Iterator> -struct iterator_difference -{ - typedef typename cutl_details_boost::detail::iterator_traits<Iterator>::difference_type type; -}; - -template <class Iterator> -struct BOOST_ITERATOR_CATEGORY -{ - typedef typename cutl_details_boost::detail::iterator_traits<Iterator>::iterator_category type; -}; - -# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) -template <> -struct iterator_value<int> -{ - typedef void type; -}; - -template <> -struct iterator_reference<int> -{ - typedef void type; -}; - -template <> -struct iterator_pointer<int> -{ - typedef void type; -}; - -template <> -struct iterator_difference<int> -{ - typedef void type; -}; - -template <> -struct BOOST_ITERATOR_CATEGORY<int> -{ - typedef void type; -}; -# endif - -} // namespace cutl_details_boost::iterator - -#endif // ITERATOR_TRAITS_DWA200347_HPP |