Swiftdiff options
Diffstat (limited to '3rdParty/Boost/boost/iterator')
| -rw-r--r-- | 3rdParty/Boost/boost/iterator/detail/config_def.hpp | 137 | ||||
| -rw-r--r-- | 3rdParty/Boost/boost/iterator/detail/config_undef.hpp | 25 | ||||
| -rw-r--r-- | 3rdParty/Boost/boost/iterator/detail/enable_if.hpp | 86 | ||||
| -rw-r--r-- | 3rdParty/Boost/boost/iterator/detail/facade_iterator_category.hpp | 200 | ||||
| -rw-r--r-- | 3rdParty/Boost/boost/iterator/detail/minimum_category.hpp | 116 | ||||
| -rw-r--r-- | 3rdParty/Boost/boost/iterator/interoperable.hpp | 50 | ||||
| -rw-r--r-- | 3rdParty/Boost/boost/iterator/iterator_adaptor.hpp | 371 | ||||
| -rw-r--r-- | 3rdParty/Boost/boost/iterator/iterator_categories.hpp | 188 | ||||
| -rw-r--r-- | 3rdParty/Boost/boost/iterator/iterator_facade.hpp | 878 | ||||
| -rw-r--r-- | 3rdParty/Boost/boost/iterator/iterator_traits.hpp | 92 | ||||
| -rw-r--r-- | 3rdParty/Boost/boost/iterator/reverse_iterator.hpp | 69 | ||||
| -rw-r--r-- | 3rdParty/Boost/boost/iterator/transform_iterator.hpp | 188 |
12 files changed, 2400 insertions, 0 deletions
diff --git a/3rdParty/Boost/boost/iterator/detail/config_def.hpp b/3rdParty/Boost/boost/iterator/detail/config_def.hpp new file mode 100644 index 0000000..fa8d667 --- /dev/null +++ b/3rdParty/Boost/boost/iterator/detail/config_def.hpp @@ -0,0 +1,137 @@ +// (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(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 <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(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/3rdParty/Boost/boost/iterator/detail/config_undef.hpp b/3rdParty/Boost/boost/iterator/detail/config_undef.hpp new file mode 100644 index 0000000..9dcd1d5 --- /dev/null +++ b/3rdParty/Boost/boost/iterator/detail/config_undef.hpp @@ -0,0 +1,25 @@ +// (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/3rdParty/Boost/boost/iterator/detail/enable_if.hpp b/3rdParty/Boost/boost/iterator/detail/enable_if.hpp new file mode 100644 index 0000000..0fd36fc --- /dev/null +++ b/3rdParty/Boost/boost/iterator/detail/enable_if.hpp @@ -0,0 +1,86 @@ +// (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 + { +# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + typedef Return type; +# endif + }; + + } // namespace iterators + +} // namespace boost + +#include <boost/iterator/detail/config_undef.hpp> + +#endif // BOOST_ENABLE_IF_23022003THW_HPP diff --git a/3rdParty/Boost/boost/iterator/detail/facade_iterator_category.hpp b/3rdParty/Boost/boost/iterator/detail/facade_iterator_category.hpp new file mode 100644 index 0000000..2c4771d --- /dev/null +++ b/3rdParty/Boost/boost/iterator/detail/facade_iterator_category.hpp @@ -0,0 +1,200 @@ +// 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 +// + +// forward declaration +namespace boost { struct use_default; } + +namespace 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> + , 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 boost::detail + +# include <boost/iterator/detail/config_undef.hpp> + +#endif // FACADE_ITERATOR_CATEGORY_DWA20031118_HPP diff --git a/3rdParty/Boost/boost/iterator/detail/minimum_category.hpp b/3rdParty/Boost/boost/iterator/detail/minimum_category.hpp new file mode 100644 index 0000000..96501dd --- /dev/null +++ b/3rdParty/Boost/boost/iterator/detail/minimum_category.hpp @@ -0,0 +1,116 @@ +// 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/type_traits/is_convertible.hpp> +# include <boost/type_traits/is_same.hpp> + +# include <boost/mpl/aux_/lambda_support.hpp> + +namespace boost { namespace detail { +// +// Returns the minimum category type or error_type +// if T1 and T2 are unrelated. +// +// For compilers not supporting is_convertible this only +// works with the new boost return and traversal category +// types. The exact boost _types_ are required. No derived types +// will work. +// +// +template <bool GreaterEqual, bool LessEqual> +struct minimum_category_impl +# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) +{ + template <class T1, class T2> struct apply + { + typedef T2 type; + }; + typedef void type; +} +# endif +; + +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> + { + }; +}; + +template <class T1 = mpl::_1, class T2 = mpl::_2> +struct minimum_category +{ + typedef minimum_category_impl< +# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround + is_same<T2,int>::value || +# endif + ::boost::is_convertible<T1,T2>::value + , ::boost::is_convertible<T2,T1>::value +# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround + || is_same<T1,int>::value +# endif + > 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)) +}; + +# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround +template <> +struct minimum_category<int,int> +{ + typedef int type; +}; +# endif + +}} // namespace boost::detail + +#endif // MINIMUM_CATEGORY_DWA20031119_HPP diff --git a/3rdParty/Boost/boost/iterator/interoperable.hpp b/3rdParty/Boost/boost/iterator/interoperable.hpp new file mode 100644 index 0000000..c13dd9b --- /dev/null +++ b/3rdParty/Boost/boost/iterator/interoperable.hpp @@ -0,0 +1,50 @@ +// (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 +{ + + // + // 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 boost + +# include <boost/iterator/detail/config_undef.hpp> + +#endif // BOOST_INTEROPERABLE_23022003THW_HPP diff --git a/3rdParty/Boost/boost/iterator/iterator_adaptor.hpp b/3rdParty/Boost/boost/iterator/iterator_adaptor.hpp new file mode 100644 index 0000000..27b08ff --- /dev/null +++ b/3rdParty/Boost/boost/iterator/iterator_adaptor.hpp @@ -0,0 +1,371 @@ +// (C) Copyright David Abrahams 2002. +// (C) Copyright Jeremy Siek 2002. +// (C) Copyright Thomas Witt 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#ifndef BOOST_ITERATOR_ADAPTOR_23022003THW_HPP +#define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP + +#include <boost/static_assert.hpp> +#include <boost/iterator.hpp> +#include <boost/detail/iterator.hpp> + +#include <boost/iterator/iterator_categories.hpp> +#include <boost/iterator/iterator_facade.hpp> +#include <boost/iterator/detail/enable_if.hpp> + +#include <boost/mpl/and.hpp> +#include <boost/mpl/not.hpp> +#include <boost/mpl/or.hpp> + +#include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/is_convertible.hpp> + +#ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY +# include <boost/type_traits/remove_reference.hpp> + +# if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610)) +# include <boost/type_traits/add_reference.hpp> +# endif + +#else +# include <boost/type_traits/add_reference.hpp> +#endif + +#include <boost/iterator/detail/config_def.hpp> + +#include <boost/iterator/iterator_traits.hpp> + +namespace boost +{ + // 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; + +# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + // 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_ {}; +# endif + + 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 BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + + template<typename From, typename To> + struct enable_if_convertible + { + typedef typename mpl::if_< + mpl::or_< + is_same<From,To> + , is_convertible<From, To> + > + , boost::detail::enable_type + , int& + >::type type; + }; + +# elif defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE) + + template <class From, class To> + struct enable_if_convertible + { + typedef boost::detail::enable_type type; + }; + +# elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292)) && BOOST_MSVC > 1300 + + // 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::detail::enable_type + > + {}; + +# else + + template<typename From, typename To> + struct enable_if_convertible + : iterators::enable_if< + is_convertible<From, To> + , boost::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::detail::ia_dflt_help< + Value + , mpl::eval_if< + is_same<Reference,use_default> + , iterator_value<Base> + , remove_reference<Reference> + > + >::type +# else + , typename boost::detail::ia_dflt_help< + Value, iterator_value<Base> + >::type +# endif + + , typename boost::detail::ia_dflt_help< + Traversal + , iterator_traversal<Base> + >::type + + , typename boost::detail::ia_dflt_help< + Reference + , mpl::eval_if< + is_same<Value,use_default> + , iterator_reference<Base> + , add_reference<Value> + > + >::type + + , typename boost::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::detail::iterator_adaptor_base< + Derived, Base, Value, Traversal, Reference, Difference + >::type + { + friend class iterator_core_access; + + protected: + typedef typename boost::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::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 boost + +#include <boost/iterator/detail/config_undef.hpp> + +#endif // BOOST_ITERATOR_ADAPTOR_23022003THW_HPP diff --git a/3rdParty/Boost/boost/iterator/iterator_categories.hpp b/3rdParty/Boost/boost/iterator/iterator_categories.hpp new file mode 100644 index 0000000..1740d98 --- /dev/null +++ b/3rdParty/Boost/boost/iterator/iterator_categories.hpp @@ -0,0 +1,188 @@ +// (C) Copyright Jeremy Siek 2002. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_ITERATOR_CATEGORIES_HPP +# define BOOST_ITERATOR_CATEGORIES_HPP + +# include <boost/config.hpp> +# include <boost/detail/iterator.hpp> +# include <boost/iterator/detail/config_def.hpp> + +# include <boost/detail/workaround.hpp> + +# include <boost/mpl/eval_if.hpp> +# include <boost/mpl/identity.hpp> +# include <boost/mpl/placeholders.hpp> +# include <boost/mpl/aux_/lambda_support.hpp> + +# include <boost/type_traits/is_convertible.hpp> + +# include <boost/static_assert.hpp> + +namespace boost { + +// +// 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> + , 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 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 boost + +#include <boost/iterator/detail/config_undef.hpp> + +#endif // BOOST_ITERATOR_CATEGORIES_HPP diff --git a/3rdParty/Boost/boost/iterator/iterator_facade.hpp b/3rdParty/Boost/boost/iterator/iterator_facade.hpp new file mode 100644 index 0000000..967d60f --- /dev/null +++ b/3rdParty/Boost/boost/iterator/iterator_facade.hpp @@ -0,0 +1,878 @@ +// (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/iterator.hpp> +#include <boost/iterator/interoperable.hpp> +#include <boost/iterator/iterator_traits.hpp> + +#include <boost/iterator/detail/facade_iterator_category.hpp> +#include <boost/iterator/detail/enable_if.hpp> + +#include <boost/implicit_cast.hpp> +#include <boost/static_assert.hpp> + +#include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/add_pointer.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/type_traits/is_convertible.hpp> +#include <boost/type_traits/is_pod.hpp> + +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/or.hpp> +#include <boost/mpl/and.hpp> +#include <boost/mpl/not.hpp> +#include <boost/mpl/always.hpp> +#include <boost/mpl/apply.hpp> +#include <boost/mpl/identity.hpp> + +#include <boost/iterator/detail/config_def.hpp> // this goes last + +namespace boost +{ + // 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 + : ::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; + + typedef typename mpl::eval_if< + 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 taht + // (*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 a lvalue to which a pointer can be formed. We do that by + // returning an instantiation of this special proxy class template. + template <class T> + struct operator_arrow_proxy + { + operator_arrow_proxy(T const* px) : m_value(*px) {} + T* operator->() const { return &m_value; } + // This function is needed for MWCW and BCC, which won't call operator-> + // again automatically per 13.3.1.2 para 8 + operator T*() const { return &m_value; } + mutable T m_value; + }; + + // A metafunction that gets the result type for operator->. Also + // has a static function make() which builds the result from a + // Reference + template <class ValueType, class Reference, class Pointer> + struct operator_arrow_result + { + // CWPro8.3 won't accept "operator_arrow_result::type", and we + // need that type below, so metafunction forwarding would be a + // losing proposition here. + typedef typename mpl::if_< + is_reference<Reference> + , Pointer + , operator_arrow_proxy<ValueType> + >::type type; + + static type make(Reference x) + { + return implicit_cast<type>(&x); + } + }; + +# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + // Deal with ETI + template<> + struct operator_arrow_result<int, int, int> + { + typedef int 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. + 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 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, 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, -, 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 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 boost::detail::iterator_facade_types< + Value, CategoryOrTraversal, Reference, Difference + > associated_types; + + 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 associated_types::pointer pointer; + typedef typename associated_types::iterator_category iterator_category; + + reference operator*() const + { + return iterator_core_access::dereference(this->derived()); + } + + typename boost::detail::operator_arrow_result< + value_type + , reference + , pointer + >::type + operator->() const + { + return boost::detail::operator_arrow_result< + value_type + , reference + , pointer + >::make(*this->derived()); + } + + typename boost::detail::operator_brackets_result<Derived,Value,reference>::type + operator[](difference_type n) const + { + typedef boost::detail::use_operator_brackets_proxy<Value,Reference> use_proxy; + + return 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 boost::detail::postfix_increment_result<Derived,Value,Reference,CategoryOrTraversal>::type + operator++(int) + { + typename 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 boost::detail::postfix_increment_result<I,V,R,TC>::type + operator++( + iterator_facade<I,V,TC,R,D>& i + , int + ) + { + typename 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 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::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( + - + , 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 boost + +#include <boost/iterator/detail/config_undef.hpp> + +#endif // BOOST_ITERATOR_FACADE_23022003THW_HPP diff --git a/3rdParty/Boost/boost/iterator/iterator_traits.hpp b/3rdParty/Boost/boost/iterator/iterator_traits.hpp new file mode 100644 index 0000000..960970e --- /dev/null +++ b/3rdParty/Boost/boost/iterator/iterator_traits.hpp @@ -0,0 +1,92 @@ +// Copyright David Abrahams 2003. +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +#ifndef ITERATOR_TRAITS_DWA200347_HPP +# define ITERATOR_TRAITS_DWA200347_HPP + +# include <boost/detail/iterator.hpp> +# include <boost/detail/workaround.hpp> + +namespace boost { + +// 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 boost::detail::iterator_traits<Iterator>::value_type type; +}; + +template <class Iterator> +struct iterator_reference +{ + typedef typename boost::detail::iterator_traits<Iterator>::reference type; +}; + + +template <class Iterator> +struct iterator_pointer +{ + typedef typename boost::detail::iterator_traits<Iterator>::pointer type; +}; + +template <class Iterator> +struct iterator_difference +{ + typedef typename boost::detail::iterator_traits<Iterator>::difference_type type; +}; + +template <class Iterator> +struct BOOST_ITERATOR_CATEGORY +{ + typedef typename 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 boost::iterator + +#endif // ITERATOR_TRAITS_DWA200347_HPP diff --git a/3rdParty/Boost/boost/iterator/reverse_iterator.hpp b/3rdParty/Boost/boost/iterator/reverse_iterator.hpp new file mode 100644 index 0000000..97b6b48 --- /dev/null +++ b/3rdParty/Boost/boost/iterator/reverse_iterator.hpp @@ -0,0 +1,69 @@ +// (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.hpp> +#include <boost/utility.hpp> +#include <boost/iterator/iterator_adaptor.hpp> + +namespace boost +{ + + // + // + // + template <class Iterator> + class reverse_iterator + : public iterator_adaptor< reverse_iterator<Iterator>, Iterator > + { + typedef iterator_adaptor< reverse_iterator<Iterator>, Iterator > super_t; + + friend class iterator_core_access; + + public: + reverse_iterator() {} + + explicit reverse_iterator(Iterator x) + : super_t(x) {} + + template<class OtherIterator> + reverse_iterator( + reverse_iterator<OtherIterator> const& r + , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 + ) + : super_t(r.base()) + {} + + private: + typename super_t::reference dereference() const { return *boost::prior(this->base()); } + + void increment() { --this->base_reference(); } + void decrement() { ++this->base_reference(); } + + void advance(typename super_t::difference_type n) + { + this->base_reference() += -n; + } + + template <class OtherIterator> + typename super_t::difference_type + distance_to(reverse_iterator<OtherIterator> const& y) const + { + return this->base_reference() - y.base(); + } + }; + + template <class BidirectionalIterator> + reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x) + { + return reverse_iterator<BidirectionalIterator>(x); + } + +} // namespace boost + +#endif // BOOST_REVERSE_ITERATOR_23022003THW_HPP diff --git a/3rdParty/Boost/boost/iterator/transform_iterator.hpp b/3rdParty/Boost/boost/iterator/transform_iterator.hpp new file mode 100644 index 0000000..e449a8b --- /dev/null +++ b/3rdParty/Boost/boost/iterator/transform_iterator.hpp @@ -0,0 +1,188 @@ +// (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/function.hpp> +#include <boost/iterator.hpp> +#include <boost/iterator/detail/enable_if.hpp> +#include <boost/iterator/iterator_adaptor.hpp> +#include <boost/iterator/iterator_categories.hpp> +#include <boost/mpl/not.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/type_traits/function_traits.hpp> +#include <boost/type_traits/is_const.hpp> +#include <boost/type_traits/is_class.hpp> +#include <boost/type_traits/is_function.hpp> +#include <boost/type_traits/is_reference.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> + +#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 +{ + template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default> + class transform_iterator; + + namespace detail + { + + template <class UnaryFunc> + struct function_object_result + { + typedef typename UnaryFunc::result_type type; + }; + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template <class Return, class Argument> + struct function_object_result<Return(*)(Argument)> + { + typedef Return type; + }; +#endif + + // 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. Do we need to adjust the way + // function_object_result is computed for the standard + // proposal (e.g. using Doug's result_of)? + typedef typename ia_dflt_help< + Reference + , function_object_result<UnaryFunc> + >::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::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type + { + typedef typename + boost::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> + 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> +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + typename mpl::if_< +#else + typename iterators::enable_if< +#endif + is_class<UnaryFunc> // We should probably find a cheaper test than is_class<> + , transform_iterator<UnaryFunc, Iterator> +#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + , int[3] +#endif + >::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> + 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 boost + +#include <boost/iterator/detail/config_undef.hpp> + +#endif // BOOST_TRANSFORM_ITERATOR_23022003THW_HPP |