function_input_iterator fixes from Dean Michael Berris

[SVN r62710]

include/boost/iterator/function_input_iterator.hpp

@@ -7,10 +7,16 @@
 #ifndef BOOST_FUNCTION_INPUT_ITERATOR
 #define BOOST_FUNCTION_INPUT_ITERATOR
 
+#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>
 
 namespace boost {
 
+    namespace impl {
+
         template <class Function, class Input>
         class function_input_iterator
             : public iterator_facade<
@@ -22,8 +28,8 @@ namespace boost {
         {
         public:
             function_input_iterator() {}
-            function_input_iterator(Function * f_, Input state_ = Input()) 
+            function_input_iterator(Function & f_, Input state_ = Input()) 
-                : f(f_), state(state_), value((*f)()) {}
+                : f(&f_), state(state_), value((*f)()) {}
 
             void increment() {
                 value = (*f)();
@@ -45,11 +51,91 @@ namespace boost {
             typename Function::result_type value;
         };
 
+        template <class Function, class Input>
+        class function_pointer_input_iterator
+            : public iterator_facade<
+            function_pointer_input_iterator<Function, Input>,
+            typename function_types::result_type<Function>::type,
+            single_pass_traversal_tag,
+            typename function_types::result_type<Function>::type const &
+            >
+        {
+        public:
+            function_pointer_input_iterator() {}
+            function_pointer_input_iterator(Function &f_, Input state_ = Input())
+                : f(f_), state(state_), value((*f)()) 
+            {}
+
+            void increment() {
+                value = (*f)();
+                ++state;
+            }
+
+            typename function_types::result_type<Function>::type const &
+                dereference() const {
+                    return value;
+            }
+
+            bool equal(function_pointer_input_iterator const & other) const {
+                return f == other.f && state == other.state;
+            }
+
+        private:
+            Function f;
+            Input state;
+            typename function_types::result_type<Function>::type value;
+        };
+
+        template <class Function, class Input>
+        class function_reference_input_iterator
+            : public function_pointer_input_iterator<Function*,Input>
+        {
+        public:
+            function_reference_input_iterator(Function & f_, Input state_ = Input())
+                : function_pointer_input_iterator<Function*,Input>(&f_, state_)
+            {}
+        };
+
+    } // namespace impl
+
+    template <class Function, class Input>
+    class function_input_iterator 
+        : public mpl::if_<
+            function_types::is_function_pointer<Function>,
+            impl::function_pointer_input_iterator<Function,Input>,
+            typename mpl::if_<
+                function_types::is_function_reference<Function>,
+                impl::function_reference_input_iterator<Function,Input>,
+                impl::function_input_iterator<Function,Input>
+            >::type
+        >::type
+    {
+        typedef typename mpl::if_<
+            function_types::is_function_pointer<Function>,
+            impl::function_pointer_input_iterator<Function,Input>,
+            typename mpl::if_<
+                function_types::is_function_reference<Function>,
+                impl::function_reference_input_iterator<Function,Input>,
+                impl::function_input_iterator<Function,Input>
+            >::type
+        >::type base_type;
+    public:
+        function_input_iterator(Function & f, Input i)
+            : base_type(f, i) {}
+    };
+
     template <class Function, class Input>
     inline function_input_iterator<Function, Input>
         make_function_input_iterator(Function & f, Input state) {
             typedef function_input_iterator<Function, Input> result_t;
-        return result_t(&f, state);
+            return result_t(f, state);
+    }
+
+    template <class Function, class Input>
+    inline function_input_iterator<Function*, Input>
+        make_function_input_iterator(Function * f, Input state) {
+            typedef function_input_iterator<Function*, Input> result_t;
+            return result_t(f, state);
     }
 
     struct infinite {

test/Jamfile.v2

@@ -43,5 +43,6 @@ test-suite iterator
     [ run iterator_traits_test.cpp ]
     [ run permutation_iterator_test.cpp : : : # <stlport-iostream>on 
     ]
+    [ run function_input_iterator_test.cpp ]
       
 ;

test/function_input_iterator_test.cpp

@@ -0,0 +1,70 @@
+// Copyright 2010 (c) Dean Michael Berris
+// 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)
+
+#include <boost/iterator/function_input_iterator.hpp>
+#include <vector>
+#include <iterator>
+#include <cassert>
+#include <algorithm>
+#include <iostream>
+
+struct ones {
+    typedef int result_type;
+    result_type operator() () {
+        return 1;
+    }
+};
+
+int ones_function () {
+    return 1;
+}
+
+using namespace std;
+
+int main(int argc, char * argv[])
+{
+    // test the iterator with function objects
+    ones ones_generator;
+    vector<int> values(10);
+    generate(values.begin(), values.end(), ones());
+    
+    vector<int> generated;
+    copy(
+        boost::make_function_input_iterator(ones_generator, 0),
+        boost::make_function_input_iterator(ones_generator, 10),
+        back_inserter(generated)
+        );
+
+    assert(values.size() == generated.size());
+    assert(equal(values.begin(), values.end(), generated.begin()));
+    cout << "function iterator test with function objects successful." << endl;
+
+    // test the iterator with normal functions
+    vector<int>().swap(generated);
+    copy(
+        boost::make_function_input_iterator(&ones_function, 0),
+        boost::make_function_input_iterator(&ones_function, 10),
+        back_inserter(generated)
+        );
+
+    assert(values.size() == generated.size());
+    assert(equal(values.begin(), values.end(), generated.begin()));
+    cout << "function iterator test with pointer to function successful." << endl;
+
+    // test the iterator with a reference to a function
+    vector<int>().swap(generated);
+    copy(
+        boost::make_function_input_iterator(ones_function, 0),
+        boost::make_function_input_iterator(ones_function, 10),
+        back_inserter(generated)
+        );
+
+    assert(values.size() == generated.size());
+    assert(equal(values.begin(), values.end(), generated.begin()));
+    cout << "function iterator test with reference to function successful." << endl;
+
+    return 0;
+}
+