diff options
author | Remko Tronçon <git@el-tramo.be> | 2010-03-28 15:46:49 (GMT) |
---|---|---|
committer | Remko Tronçon <git@el-tramo.be> | 2010-03-28 15:46:49 (GMT) |
commit | f53a1ef582494458301b97bf6e546be52d7ff7e8 (patch) | |
tree | 7571b5cbcbd8a8f1dd1c966c9045b6cb69f0e295 /3rdParty/Boost/src/boost/iterator/transform_iterator.hpp | |
parent | 638345680d72ca6acaf123f2c8c1c391f696e371 (diff) | |
download | swift-contrib-f53a1ef582494458301b97bf6e546be52d7ff7e8.zip swift-contrib-f53a1ef582494458301b97bf6e546be52d7ff7e8.tar.bz2 |
Moving submodule contents back.
Diffstat (limited to '3rdParty/Boost/src/boost/iterator/transform_iterator.hpp')
-rw-r--r-- | 3rdParty/Boost/src/boost/iterator/transform_iterator.hpp | 188 |
1 files changed, 188 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/iterator/transform_iterator.hpp b/3rdParty/Boost/src/boost/iterator/transform_iterator.hpp new file mode 100644 index 0000000..e449a8b --- /dev/null +++ b/3rdParty/Boost/src/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 |