optional_optimization branch

[SVN r77091]

doc/function_input_iterator.rst

@@ -1,13 +1,10 @@
 :Author:
-    `Dean Michael Berris <mailto:me@deanberris.com>`_
+    `Dean Michael Berris <mailto:mikhailberis@gmail.com>`_
 
 :License:
     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)
 
-:Copyright:
-    Copyright 2012 Google, Inc.
-
 Function Input Iterator
 =======================
 
@@ -18,14 +15,11 @@ the iterator has been incremented. A Function Input Iterator models the
 
 .. _InputIterator: http://www.sgi.com/tech/stl/InputIterator.html
 
-The Function Input Iterator takes a function that models the Generator_ concept
-(which is basically a nullary or 0-arity function object). The first dereference
-of the iterator at a given position invokes the generator function and stores
-and returns the result; subsequent dereferences at the same position simply
-return the same stored result. Incrementing the iterator places it at a new
-position, hence a subsequent dereference will generate a new value via another
-invokation of the generator function. This ensures the generator function is
-invoked precisely when the iterator is requested to return a (new) value.
+Like the Generator Iterator, the Function Input Iterator takes a function
+that models the Generator_ concept (which is basically a nullary or 0-arity
+function object). Each increment of the function Function Input Iterator
+invokes the generator function and stores the value in the iterator. When
+the iterator is dereferenced the stored value is returned.
 
 .. _Generator: http://www.sgi.com/tech/stl/Generator.html
 
@@ -64,7 +58,7 @@ Synopsis
 
         template <class Function, class State>
         typename function_input_iterator<Function, State>
-        make_function_input_iterator(Function & f, State s);
+        make_function_input_iterator(Function & f);
 
         struct infinite;
     }
@@ -118,7 +112,7 @@ it with the ``boost::infinite`` helper class.
     copy(
             make_function_input_iterator(f,infinite()),
             make_function_input_iterator(f,infinite()),
-            ostream_iterator<int>(cout, " ")
+            ostream_iterator<int>(count, " ")
         );
    
 Above, instead of creating a huge vector we rely on the STL copy algorithm

doc/transform_iterator.html

@@ -99,7 +99,7 @@ private:
 </pre>
 <p>If <tt class="docutils literal"><span class="pre">Reference</span></tt> is <tt class="docutils literal"><span class="pre">use_default</span></tt> then the <tt class="docutils literal"><span class="pre">reference</span></tt> member of
 <tt class="docutils literal"><span class="pre">transform_iterator</span></tt> is
-<tt class="docutils literal"><span class="pre">result_of&lt;const UnaryFunction(iterator_traits&lt;Iterator&gt;::reference)&gt;::type</span></tt>.
+<tt class="docutils literal"><span class="pre">result_of&lt;UnaryFunction(iterator_traits&lt;Iterator&gt;::reference)&gt;::type</span></tt>.
 Otherwise, <tt class="docutils literal"><span class="pre">reference</span></tt> is <tt class="docutils literal"><span class="pre">Reference</span></tt>.</p>
 <p>If <tt class="docutils literal"><span class="pre">Value</span></tt> is <tt class="docutils literal"><span class="pre">use_default</span></tt> then the <tt class="docutils literal"><span class="pre">value_type</span></tt> member is
 <tt class="docutils literal"><span class="pre">remove_cv&lt;remove_reference&lt;reference&gt;</span> <span class="pre">&gt;::type</span></tt>.  Otherwise,
@@ -117,10 +117,10 @@ convertible to <tt class="docutils literal"><span class="pre">input_iterator_tag
 <div class="section" id="transform-iterator-requirements">
 <h1><a class="toc-backref" href="#id3"><tt class="docutils literal"><span class="pre">transform_iterator</span></tt> requirements</a></h1>
 <p>The type <tt class="docutils literal"><span class="pre">UnaryFunction</span></tt> must be Assignable, Copy Constructible, and
-the expression <tt class="docutils literal"><span class="pre">f(*i)</span></tt> must be valid where <tt class="docutils literal"><span class="pre">f</span></tt> is a const object of
+the expression <tt class="docutils literal"><span class="pre">f(*i)</span></tt> must be valid where <tt class="docutils literal"><span class="pre">f</span></tt> is an object of
 type <tt class="docutils literal"><span class="pre">UnaryFunction</span></tt>, <tt class="docutils literal"><span class="pre">i</span></tt> is an object of type <tt class="docutils literal"><span class="pre">Iterator</span></tt>, and
 where the type of <tt class="docutils literal"><span class="pre">f(*i)</span></tt> must be
-<tt class="docutils literal"><span class="pre">result_of&lt;const UnaryFunction(iterator_traits&lt;Iterator&gt;::reference)&gt;::type</span></tt>.</p>
+<tt class="docutils literal"><span class="pre">result_of&lt;UnaryFunction(iterator_traits&lt;Iterator&gt;::reference)&gt;::type</span></tt>.</p>
 <p>The argument <tt class="docutils literal"><span class="pre">Iterator</span></tt> shall model Readable Iterator.</p>
 </div>
 <div class="section" id="transform-iterator-models">

doc/transform_iterator_ref.rst

@@ -41,7 +41,7 @@
 
 If ``Reference`` is ``use_default`` then the ``reference`` member of
 ``transform_iterator`` is
-``result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
+``result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
 Otherwise, ``reference`` is ``Reference``.
 
 If ``Value`` is ``use_default`` then the ``value_type`` member is
@@ -64,10 +64,10 @@ convertible to ``input_iterator_tag``.
 ...................................
 
 The type ``UnaryFunction`` must be Assignable, Copy Constructible, and
-the expression ``f(*i)`` must be valid where ``f`` is a const object of
+the expression ``f(*i)`` must be valid where ``f`` is an object of
 type ``UnaryFunction``, ``i`` is an object of type ``Iterator``, and
 where the type of ``f(*i)`` must be
-``result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
+``result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
 
 The argument ``Iterator`` shall model Readable Iterator.  
 

include/boost/iterator/function_input_iterator.hpp

@@ -1,6 +1,4 @@
 // Copyright 2009 (C) Dean Michael Berris <me@deanberris.com>
-// Copyright 2012 (C) Google, Inc.
-// Copyright 2012 (C) Jeffrey Lee Hellrung, Jr.
 // 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)
@@ -9,14 +7,11 @@
 #ifndef BOOST_FUNCTION_INPUT_ITERATOR
 #define BOOST_FUNCTION_INPUT_ITERATOR
 
-#include <boost/assert.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/function_types/is_function_pointer.hpp>
 #include <boost/function_types/is_function_reference.hpp>
 #include <boost/function_types/result_type.hpp>
 #include <boost/iterator/iterator_facade.hpp>
-#include <boost/none.hpp>
-#include <boost/optional/optional.hpp>
 
 namespace boost {
 
@@ -34,19 +29,16 @@ namespace boost {
         public:
             function_input_iterator() {}
             function_input_iterator(Function & f_, Input state_ = Input()) 
-                : f(&f_), state(state_) {}
+                : f(&f_), state(state_), value((*f)()) {}
 
             void increment() {
-                if(value)
-                    value = none;
-                else
-                    (*f)();
+                value = (*f)();
                 ++state;
             }
 
             typename Function::result_type const & 
                 dereference() const {
-                    return (value ? value : value = (*f)()).get();
+                    return value;
             }
 
             bool equal(function_input_iterator const & other) const {
@@ -56,7 +48,7 @@ namespace boost {
         private:
             Function * f;
             Input state;
-            mutable optional<typename Function::result_type> value;
+            typename Function::result_type value;
         };
 
         template <class Function, class Input>
@@ -71,19 +63,17 @@ namespace boost {
         public:
             function_pointer_input_iterator() {}
             function_pointer_input_iterator(Function &f_, Input state_ = Input())
-                : f(f_), state(state_) {}
+                : f(f_), state(state_), value((*f)()) 
+            {}
 
             void increment() {
-                if(value)
-                    value = none;
-                else
-                    (*f)();
+                value = (*f)();
                 ++state;
             }
 
             typename function_types::result_type<Function>::type const &
                 dereference() const {
-                    return (value ? value : value = (*f)()).get();
+                    return value;
             }
 
             bool equal(function_pointer_input_iterator const & other) const {
@@ -93,7 +83,7 @@ namespace boost {
         private:
             Function f;
             Input state;
-            mutable optional<typename function_types::result_type<Function>::type> value;
+            typename function_types::result_type<Function>::type value;
         };
 
         template <class Function, class Input>

include/boost/iterator/iterator_facade.hpp

@@ -14,8 +14,8 @@
 #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/utility/addressof.hpp>
 
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/add_const.hpp>
@@ -147,7 +147,7 @@ namespace boost
 
         // 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
+        // behavior of the value_type.  In particular, recall taht
         // (*r).mutate() is legal if operator* returns by value.
         value_type&
         operator*() const
@@ -294,43 +294,46 @@ namespace boost
 
     // 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
+    // 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
     {
-        struct proxy
-        {
-            explicit proxy(Reference const & x) : m_ref(x) {}
-            Reference* operator->() { return 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 boost::addressof(m_ref); }
-            Reference m_ref;
-        };
-        typedef proxy result_type;
-        static result_type apply(Reference const & x)
-        {
-            return result_type(x);
-        }
+        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;
     };
 
-    template <class T, class Pointer>
-    struct operator_arrow_dispatch<T&, Pointer> // "real" references
+    // 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
     {
-        typedef Pointer result_type;
-        static result_type apply(T& x)
+        // 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 boost::addressof(x);
+            return boost::implicit_cast<type>(&x);
         }
     };
 
 # if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
     // Deal with ETI
     template<>
-    struct operator_arrow_dispatch<int, int>
+    struct operator_arrow_result<int, int, int>
     {
-        typedef int result_type;
+        typedef int type;
     };
 # endif
 
@@ -615,10 +618,11 @@ namespace boost
          Value, CategoryOrTraversal, Reference, Difference
       > associated_types;
 
-      typedef boost::detail::operator_arrow_dispatch<
-          Reference
+      typedef boost::detail::operator_arrow_result<
+        typename associated_types::value_type
+        , Reference
         , typename associated_types::pointer
-      > operator_arrow_dispatch_;
+      > pointer_;
 
    protected:
       // For use by derived classes
@@ -630,7 +634,7 @@ namespace boost
       typedef Reference reference;
       typedef Difference difference_type;
 
-      typedef typename operator_arrow_dispatch_::result_type pointer;
+      typedef typename pointer_::type pointer;
 
       typedef typename associated_types::iterator_category iterator_category;
 
@@ -641,7 +645,7 @@ namespace boost
 
       pointer operator->() const
       {
-          return operator_arrow_dispatch_::apply(*this->derived());
+          return pointer_::make(*this->derived());
       }
         
       typename boost::detail::operator_brackets_result<Derived,Value,reference>::type

include/boost/iterator/reverse_iterator.hpp

@@ -7,8 +7,8 @@
 #ifndef BOOST_REVERSE_ITERATOR_23022003THW_HPP
 #define BOOST_REVERSE_ITERATOR_23022003THW_HPP
 
-#include <boost/next_prior.hpp>
 #include <boost/iterator.hpp>
+#include <boost/utility.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 
 namespace boost

include/boost/iterator/transform_iterator.hpp

@@ -46,7 +46,7 @@ namespace boost
         // the function.
         typedef typename ia_dflt_help<
             Reference
-          , result_of<const UnaryFunc(typename std::iterator_traits<Iterator>::reference)>
+          , result_of<UnaryFunc(typename std::iterator_traits<Iterator>::reference)>
         >::type reference;
 
         // To get the default for Value: remove any reference on the

test/function_input_iterator_test.cpp

@@ -3,17 +3,12 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
+#include <boost/iterator/function_input_iterator.hpp>
+#include <vector>
+#include <iterator>
 #include <cassert>
-#include <cstddef>
-
 #include <algorithm>
 #include <iostream>
-#include <iterator>
-#include <vector>
-
-#include <boost/iterator/function_input_iterator.hpp>
-
-namespace {
 
 struct ones {
     typedef int result_type;
@@ -26,17 +21,6 @@ int ones_function () {
     return 1;
 }
 
-struct counter {
-    typedef int result_type;
-    int n;
-    explicit counter(int n_) : n(n_) { }
-    result_type operator() () {
-        return n++;
-    }
-};
-
-} // namespace
-
 using namespace std;
 
 int main(int argc, char * argv[])
@@ -81,21 +65,6 @@ int main(int argc, char * argv[])
     assert(equal(values.begin(), values.end(), generated.begin()));
     cout << "function iterator test with reference to function successful." << endl;
 
-    // test the iterator with a stateful function object
-    counter counter_generator(42);
-    vector<int>().swap(generated);
-    copy(
-        boost::make_function_input_iterator(counter_generator, 0),
-        boost::make_function_input_iterator(counter_generator, 10),
-        back_inserter(generated)
-        );
-
-    assert(generated.size() == 10);
-    assert(counter_generator.n == 42 + 10);
-    for(std::size_t i = 0; i != 10; ++i)
-        assert(generated[i] == 42 + i);
-    cout << "function iterator test with stateful function object successful." << endl;
-
     return 0;
 }
 

test/iterator_facade.cpp

@@ -7,10 +7,6 @@
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iterator/new_iterator_tests.hpp>
 
-#include <boost/call_traits.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/utility/enable_if.hpp>
-
 // This is a really, really limited test so far.  All we're doing
 // right now is checking that the postfix++ proxy for single-pass
 // iterators works properly.
@@ -91,76 +87,26 @@ struct input_iter
     }
 };
 
-template <class T>
-struct wrapper
-{
-    T m_x;
-    explicit wrapper(typename boost::call_traits<T>::param_type x)
-        : m_x(x)
-    { }
-    template <class U>
-    wrapper(const wrapper<U>& other,
-        typename boost::enable_if< boost::is_convertible<U,T> >::type* = 0)
-        : m_x(other.m_x)
-    { }
-};
-
-struct iterator_with_proxy_reference
-    : boost::iterator_facade<
-          iterator_with_proxy_reference
-        , wrapper<int>
-        , boost::incrementable_traversal_tag
-        , wrapper<int&>
-      >
-{
-    int& m_x;
-    explicit iterator_with_proxy_reference(int& x)
-        : m_x(x)
-    { }
-
-    void increment()
-    { }
-    wrapper<int&> dereference() const
-    { return wrapper<int&>(m_x); }
-};
-
 template <class T, class U>
 void same_type(U const&)
 { BOOST_MPL_ASSERT((boost::is_same<T,U>)); }
 
 int main()
 {
-    {
-        int state = 0;
-        boost::readable_iterator_test(counter_iterator<int const&>(&state), 0);
-        state = 3;
-        boost::readable_iterator_test(counter_iterator<proxy>(&state), 3);
-        boost::writable_iterator_test(counter_iterator<proxy>(&state), 9, 7);
-        BOOST_TEST(state == 8);
-    }
+    int state = 0;
+    boost::readable_iterator_test(counter_iterator<int const&>(&state), 0);
+    state = 3;
+    boost::readable_iterator_test(counter_iterator<proxy>(&state), 3);
+    boost::writable_iterator_test(counter_iterator<proxy>(&state), 9, 7);
+    BOOST_TEST(state == 8);
 
-    {
-        // test for a fix to http://tinyurl.com/zuohe
-        // These two lines should be equivalent (and both compile)
-        input_iter p;
-        (*p).mutator();
-        p->mutator();
-
-        same_type<input_iter::pointer>(p.operator->());
-    }
-
-    {
-        int x = 0;
-        iterator_with_proxy_reference i(x);
-        BOOST_TEST(x == 0);
-        BOOST_TEST(i.m_x == 0);
-        ++(*i).m_x;
-        BOOST_TEST(x == 1);
-        BOOST_TEST(i.m_x == 1);
-        ++i->m_x;
-        BOOST_TEST(x == 2);
-        BOOST_TEST(i.m_x == 2);
-    }
+    // test for a fix to http://tinyurl.com/zuohe
+    // These two lines should be equivalent (and both compile)
+    input_iter p;
+    (*p).mutator();
+    p->mutator();
 
+    same_type<input_iter::pointer>(p.operator->());
+    
     return boost::report_errors();
 }

test/transform_iterator_test.cpp

@@ -12,7 +12,6 @@
 //       Moved test of transform iterator into its own file. It to
 //       to be in iterator_adaptor_test.cpp.
 
-#include <boost/assert.hpp>
 #include <boost/config.hpp>
 #include <algorithm>
 #include <boost/iterator/transform_iterator.hpp>
@@ -107,17 +106,12 @@ struct polymorphic_mult_functor
 {
     //Implement result_of protocol
     template <class FArgs> struct result;
-    template <class F, class T> struct result<const F(T       )> {typedef T type;};
-    template <class F, class T> struct result<const F(T&      )> {typedef T type;};
-    template <class F, class T> struct result<const F(const T&)> {typedef T type;};
-    template <class F, class T> struct result<F(T       )> {typedef void type;};
-    template <class F, class T> struct result<F(T&      )> {typedef void type;};
-    template <class F, class T> struct result<F(const T&)> {typedef void type;};
+    template <class F, class T> struct result<F(T       )> {typedef T type;};
+    template <class F, class T> struct result<F(T&      )> {typedef T type;};
+    template <class F, class T> struct result<F(const T&)> {typedef T type;};
 
     template <class T> 
     T operator()(const T& _arg) const {return _arg*2;}
-    template <class T> 
-    void operator()(const T& _arg) { BOOST_ASSERT(0); }
 };
 
 int