FM / iterator

/usr/include/boost/iterator

Name	Size	Mode	Actions
detail/	-	0755	rm
advance.hpp	2056	0644	edit dl rm
counting_iterator.hpp	6280	0644	edit dl rm
distance.hpp	1868	0644	edit dl rm
filter_iterator.hpp	3904	0644	edit dl rm
function_input_iterator.hpp	5608	0644	edit dl rm
function_output_iterator.hpp	1738	0644	edit dl rm
indirect_iterator.hpp	3858	0644	edit dl rm
interoperable.hpp	1557	0644	edit dl rm
is_lvalue_iterator.hpp	4215	0644	edit dl rm
is_readable_iterator.hpp	2927	0644	edit dl rm
iterator_adaptor.hpp	11142	0644	edit dl rm
iterator_archetypes.hpp	15521	0644	edit dl rm
iterator_categories.hpp	6214	0644	edit dl rm
iterator_concepts.hpp	7401	0644	edit dl rm
iterator_facade.hpp	34735	0644	edit dl rm
iterator_traits.hpp	1451	0644	edit dl rm
minimum_category.hpp	2256	0644	edit dl rm
new_iterator_tests.hpp	7330	0644	edit dl rm
permutation_iterator.hpp	2363	0644	edit dl rm
reverse_iterator.hpp	2055	0644	edit dl rm
transform_iterator.hpp	5921	0644	edit dl rm
zip_iterator.hpp	10404	0644	edit dl rm

Edit: /usr/include/boost/iterator/function_input_iterator.hpp (5608B)

// 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)
//

#ifndef BOOST_FUNCTION_INPUT_ITERATOR
#define BOOST_FUNCTION_INPUT_ITERATOR

#include <boost/config.hpp>
#include <boost/assert.hpp>
#include <boost/core/addressof.hpp>
#include <boost/mpl/if.hpp>
#include <boost/function_types/is_function_pointer.hpp>
#include <boost/function_types/result_type.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/none.hpp>
#include <boost/optional/optional.hpp>
#include <boost/utility/result_of.hpp>

#ifdef BOOST_RESULT_OF_USE_TR1
#include <boost/type_traits/is_function.hpp>
#endif

namespace boost {

namespace iterators {

namespace impl {

// Computes the return type of an lvalue-call with an empty argument,
        // i.e. decltype(declval<F&>()()). F should be a nullary lvalue-callable
        // or function.
        template <class F>
        struct result_of_nullary_lvalue_call
        {
            typedef typename result_of<
#ifdef BOOST_RESULT_OF_USE_TR1
                typename mpl::if_<is_function<F>, F&, F>::type()
#else
                F&()
#endif
            >::type type;
        };

template <class Function, class Input>
        class function_input_iterator
            : public iterator_facade<
            function_input_iterator<Function, Input>,
            typename result_of_nullary_lvalue_call<Function>::type,
            single_pass_traversal_tag,
            typename result_of_nullary_lvalue_call<Function>::type const &
            >
        {
        public:
            function_input_iterator() {}
            function_input_iterator(Function & f_, Input state_ = Input())
                : f(boost::addressof(f_)), state(state_) {}

void increment() {
                if(value)
                    value = none;
                else
                    (*f)();
                ++state;
            }

typename result_of_nullary_lvalue_call<Function>::type const &
                dereference() const {
                    return (value ? value : value = (*f)()).get();
            }

bool equal(function_input_iterator const & other) const {
                return f == other.f && state == other.state;
            }

private:
            Function * f;
            Input state;
            mutable optional<typename result_of_nullary_lvalue_call<Function>::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_) {}

void increment() {
                if(value)
                    value = none;
                else
                    (*f)();
                ++state;
            }

typename function_types::result_type<Function>::type const &
                dereference() const {
                    return (value ? value : value = (*f)()).get();
            }

bool equal(function_pointer_input_iterator const & other) const {
                return f == other.f && state == other.state;
            }

private:
            Function f;
            Input state;
            mutable optional<typename function_types::result_type<Function>::type> value;
        };

} // 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>,
            impl::function_input_iterator<Function,Input>
        >::type
    {
        typedef typename mpl::if_<
            function_types::is_function_pointer<Function>,
            impl::function_pointer_input_iterator<Function,Input>,
            impl::function_input_iterator<Function,Input>
        >::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);
    }

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 {
        infinite & operator++() { return *this; }
        infinite & operator++(int) { return *this; }
        bool operator==(infinite &) const { return false; };
        bool operator==(infinite const &) const { return false; };
    };

} // namespace iterators

using iterators::function_input_iterator;
using iterators::make_function_input_iterator;
using iterators::infinite;

} // namespace boost

#endif

// Copyright 2009 (C) Dean Michael Berris // 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) // #ifndef BOOST_FUNCTION_INPUT_ITERATOR #define BOOST_FUNCTION_INPUT_ITERATOR #include #include #include #include #include #include #include #include #include #include #ifdef BOOST_RESULT_OF_USE_TR1 #include #endif namespace boost { namespace iterators { namespace impl { // Computes the return type of an lvalue-call with an empty argument, // i.e. decltype(declval()()). F should be a nullary lvalue-callable // or function. template struct result_of_nullary_lvalue_call { typedef typename result_of< #ifdef BOOST_RESULT_OF_USE_TR1 typename mpl::if_, F&, F>::type() #else F&() #endif >::type type; }; template class function_input_iterator : public iterator_facade< function_input_iterator, typename result_of_nullary_lvalue_call::type, single_pass_traversal_tag, typename result_of_nullary_lvalue_call::type const & > { public: function_input_iterator() {} function_input_iterator(Function & f_, Input state_ = Input()) : f(boost::addressof(f_)), state(state_) {} void increment() { if(value) value = none; else (*f)(); ++state; } typename result_of_nullary_lvalue_call::type const & dereference() const { return (value ? value : value = (*f)()).get(); } bool equal(function_input_iterator const & other) const { return f == other.f && state == other.state; } private: Function * f; Input state; mutable optional::type> value; }; template class function_pointer_input_iterator : public iterator_facade< function_pointer_input_iterator, typename function_types::result_type::type, single_pass_traversal_tag, typename function_types::result_type::type const & > { public: function_pointer_input_iterator() {} function_pointer_input_iterator(Function &f_, Input state_ = Input()) : f(f_), state(state_) {} void increment() { if(value) value = none; else (*f)(); ++state; } typename function_types::result_type::type const & dereference() const { return (value ? value : value = (*f)()).get(); } bool equal(function_pointer_input_iterator const & other) const { return f == other.f && state == other.state; } private: Function f; Input state; mutable optional::type> value; }; } // namespace impl template class function_input_iterator : public mpl::if_< function_types::is_function_pointer, impl::function_pointer_input_iterator, impl::function_input_iterator >::type { typedef typename mpl::if_< function_types::is_function_pointer, impl::function_pointer_input_iterator, impl::function_input_iterator >::type base_type; public: function_input_iterator(Function & f, Input i) : base_type(f, i) {} }; template inline function_input_iterator make_function_input_iterator(Function & f, Input state) { typedef function_input_iterator result_t; return result_t(f, state); } template inline function_input_iterator make_function_input_iterator(Function * f, Input state) { typedef function_input_iterator result_t; return result_t(f, state); } struct infinite { infinite & operator++() { return *this; } infinite & operator++(int) { return *this; } bool operator==(infinite &) const { return false; }; bool operator==(infinite const &) const { return false; }; }; } // namespace iterators using iterators::function_input_iterator; using iterators::make_function_input_iterator; using iterators::infinite; } // namespace boost #endif