整理

include/boost/iterator/transform_iterator.hpp

@@ -0,0 +1,146 @@
+// (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_TRANSFORM_ITERATOR_23022003THW_HPP
+#define BOOST_ITERATOR_TRANSFORM_ITERATOR_23022003THW_HPP
+
+#include <iterator>
+#include <type_traits>
+
+#include <boost/core/use_default.hpp>
+#include <boost/core/empty_value.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/enable_if_convertible.hpp>
+#include <boost/iterator/detail/eval_if_default.hpp>
+
+namespace boost {
+namespace iterators {
+
+template<
+    typename UnaryFunction,
+    typename Iterator,
+    typename Reference = use_default,
+    typename Value = use_default
+>
+class transform_iterator;
+
+namespace detail {
+
+template< typename UnaryFunc, typename Iterator >
+struct transform_iterator_default_reference
+{
+    using type = decltype(std::declval< UnaryFunc const& >()(std::declval< typename std::iterator_traits< Iterator >::reference >()));
+};
+
+// Compute the iterator_adaptor instantiation to be used for transform_iterator
+template< typename UnaryFunc, typename Iterator, typename Reference, typename Value >
+struct transform_iterator_base
+{
+private:
+    // By default, dereferencing the iterator yields the same as
+    // the function.
+    using reference = detail::eval_if_default_t<
+        Reference,
+        transform_iterator_default_reference< UnaryFunc, Iterator >
+    >;
+
+    // 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.
+    using cv_value_type = detail::eval_if_default_t<
+        Value,
+        std::remove_reference< reference >
+    >;
+
+public:
+    using type = iterator_adaptor<
+        transform_iterator< UnaryFunc, Iterator, Reference, Value >,
+        Iterator,
+        cv_value_type,
+        use_default,    // Leave the traversal category alone
+        reference
+    >;
+};
+
+} // namespace detail
+
+template< typename UnaryFunc, typename Iterator, typename Reference, typename Value >
+class transform_iterator :
+    public detail::transform_iterator_base< UnaryFunc, Iterator, Reference, Value >::type,
+    private boost::empty_value< UnaryFunc >
+{
+    friend class iterator_core_access;
+
+private:
+    using super_t = typename detail::transform_iterator_base< UnaryFunc, Iterator, Reference, Value >::type;
+    using functor_base = boost::empty_value< UnaryFunc >;
+
+public:
+    transform_iterator() = default;
+
+    transform_iterator(Iterator const& x, UnaryFunc f) :
+        super_t(x),
+        functor_base(boost::empty_init_t{}, f)
+    {}
+
+    // don't provide this constructor if UnaryFunc is a
+    // function pointer type, since it will be 0.  Too dangerous.
+    template< bool Requires = std::is_class< UnaryFunc >::value, typename = typename std::enable_if< Requires >::type >
+    explicit transform_iterator(Iterator const& x) :
+        super_t(x)
+    {}
+
+    template<
+        typename OtherUnaryFunction,
+        typename OtherIterator,
+        typename OtherReference,
+        typename OtherValue,
+        typename = enable_if_convertible_t< OtherIterator, Iterator >,
+        typename = enable_if_convertible_t< OtherUnaryFunction, UnaryFunc >
+    >
+    transform_iterator(transform_iterator< OtherUnaryFunction, OtherIterator, OtherReference, OtherValue > const& t) :
+        super_t(t.base()),
+        functor_base(boost::empty_init_t{}, t.functor())
+    {}
+
+    UnaryFunc functor() const { return functor_base::get(); }
+
+private:
+    typename super_t::reference dereference() const { return functor_base::get()(*this->base()); }
+};
+
+template< typename UnaryFunc, typename Iterator >
+inline transform_iterator< UnaryFunc, Iterator > make_transform_iterator(Iterator it, UnaryFunc fun)
+{
+    return transform_iterator< UnaryFunc, Iterator >(it, fun);
+}
+
+// Version which allows explicit specification of the UnaryFunc
+// type.
+//
+// This generator is not provided if UnaryFunc is a function
+// pointer type, because it's too dangerous: the default-constructed
+// function pointer in the iterator be 0, leading to a runtime
+// crash.
+template< typename UnaryFunc, typename Iterator >
+inline typename std::enable_if<
+    std::is_class< UnaryFunc >::value,   // We should probably find a cheaper test than is_class<>
+    transform_iterator< UnaryFunc, Iterator >
+>::type make_transform_iterator(Iterator it)
+{
+    return transform_iterator< UnaryFunc, Iterator >(it);
+}
+
+} // namespace iterators
+
+using iterators::transform_iterator;
+using iterators::make_transform_iterator;
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_TRANSFORM_ITERATOR_23022003THW_HPP