Merge c:/dyninst/pc_bluegene/dyninst into dyn_pc_integration
[dyninst.git] / external / boost / iterator / transform_iterator.hpp
1 // (C) Copyright David Abrahams 2002.
2 // (C) Copyright Jeremy Siek    2002.
3 // (C) Copyright Thomas Witt    2002.
4 // Distributed under the Boost Software License, Version 1.0. (See
5 // accompanying file LICENSE_1_0.txt or copy at
6 // http://www.boost.org/LICENSE_1_0.txt)
7 #ifndef BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
8 #define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
9
10 #include <boost/function.hpp>
11 #include <boost/iterator.hpp>
12 #include <boost/iterator/detail/enable_if.hpp>
13 #include <boost/iterator/iterator_adaptor.hpp>
14 #include <boost/iterator/iterator_categories.hpp>
15 #include <boost/mpl/not.hpp>
16 #include <boost/mpl/bool.hpp>
17 #include <boost/type_traits/function_traits.hpp>
18 #include <boost/type_traits/is_const.hpp>
19 #include <boost/type_traits/is_class.hpp>
20 #include <boost/type_traits/is_function.hpp>
21 #include <boost/type_traits/is_reference.hpp>
22 #include <boost/type_traits/remove_const.hpp>
23 #include <boost/type_traits/remove_reference.hpp>
24
25 #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
26 # include <boost/type_traits/is_base_and_derived.hpp>
27
28 #endif 
29 #include <boost/iterator/detail/config_def.hpp>
30
31
32 namespace boost
33 {
34   template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default>
35   class transform_iterator;
36
37   namespace detail 
38   {
39
40     template <class UnaryFunc>
41     struct function_object_result
42     {
43       typedef typename UnaryFunc::result_type type;
44     };
45
46 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
47     template <class Return, class Argument>
48     struct function_object_result<Return(*)(Argument)>
49     {
50       typedef Return type;
51     };
52 #endif
53
54     // Compute the iterator_adaptor instantiation to be used for transform_iterator
55     template <class UnaryFunc, class Iterator, class Reference, class Value>
56     struct transform_iterator_base
57     {
58      private:
59         // By default, dereferencing the iterator yields the same as
60         // the function.  Do we need to adjust the way
61         // function_object_result is computed for the standard
62         // proposal (e.g. using Doug's result_of)?
63         typedef typename ia_dflt_help<
64             Reference
65           , function_object_result<UnaryFunc>
66         >::type reference;
67
68         // To get the default for Value: remove any reference on the
69         // result type, but retain any constness to signal
70         // non-writability.  Note that if we adopt Thomas' suggestion
71         // to key non-writability *only* on the Reference argument,
72         // we'd need to strip constness here as well.
73         typedef typename ia_dflt_help<
74             Value
75           , remove_reference<reference>
76         >::type cv_value_type;
77
78      public:
79         typedef iterator_adaptor<
80             transform_iterator<UnaryFunc, Iterator, Reference, Value>
81           , Iterator
82           , cv_value_type
83           , use_default    // Leave the traversal category alone
84           , reference
85         > type;
86     };
87   }
88
89   template <class UnaryFunc, class Iterator, class Reference, class Value>
90   class transform_iterator
91     : public boost::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
92   {
93     typedef typename
94     boost::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
95     super_t;
96
97     friend class iterator_core_access;
98
99   public:
100     transform_iterator() { }
101
102     transform_iterator(Iterator const& x, UnaryFunc f)
103       : super_t(x), m_f(f) { }
104
105     explicit transform_iterator(Iterator const& x)
106       : super_t(x)
107     {
108         // Pro8 is a little too aggressive about instantiating the
109         // body of this function.
110 #if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
111         // don't provide this constructor if UnaryFunc is a
112         // function pointer type, since it will be 0.  Too dangerous.
113         BOOST_STATIC_ASSERT(is_class<UnaryFunc>::value);
114 #endif 
115     }
116
117     template<
118         class OtherUnaryFunction
119       , class OtherIterator
120       , class OtherReference
121       , class OtherValue>
122     transform_iterator(
123          transform_iterator<OtherUnaryFunction, OtherIterator, OtherReference, OtherValue> const& t
124        , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
125 #if !BOOST_WORKAROUND(BOOST_MSVC, == 1310)
126        , typename enable_if_convertible<OtherUnaryFunction, UnaryFunc>::type* = 0
127 #endif 
128     )
129       : super_t(t.base()), m_f(t.functor())
130    {}
131
132     UnaryFunc functor() const
133       { return m_f; }
134
135   private:
136     typename super_t::reference dereference() const
137     { return m_f(*this->base()); }
138
139     // Probably should be the initial base class so it can be
140     // optimized away via EBO if it is an empty class.
141     UnaryFunc m_f;
142   };
143
144   template <class UnaryFunc, class Iterator>
145   transform_iterator<UnaryFunc, Iterator>
146   make_transform_iterator(Iterator it, UnaryFunc fun)
147   {
148       return transform_iterator<UnaryFunc, Iterator>(it, fun);
149   }
150
151   // Version which allows explicit specification of the UnaryFunc
152   // type.
153   //
154   // This generator is not provided if UnaryFunc is a function
155   // pointer type, because it's too dangerous: the default-constructed
156   // function pointer in the iterator be 0, leading to a runtime
157   // crash.
158   template <class UnaryFunc, class Iterator>
159 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
160   typename mpl::if_<
161 #else 
162   typename iterators::enable_if<
163 #endif 
164       is_class<UnaryFunc>   // We should probably find a cheaper test than is_class<>
165     , transform_iterator<UnaryFunc, Iterator>
166 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
167     , int[3]
168 #endif 
169   >::type
170   make_transform_iterator(Iterator it)
171   {
172       return transform_iterator<UnaryFunc, Iterator>(it, UnaryFunc());
173   }
174
175 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
176   template <class Return, class Argument, class Iterator>
177   transform_iterator< Return (*)(Argument), Iterator, Return>
178   make_transform_iterator(Iterator it, Return (*fun)(Argument))
179   {
180     return transform_iterator<Return (*)(Argument), Iterator, Return>(it, fun);
181   }
182 #endif
183
184 } // namespace boost
185
186 #include <boost/iterator/detail/config_undef.hpp>
187
188 #endif // BOOST_TRANSFORM_ITERATOR_23022003THW_HPP