mirror/meta_prog/for_each.hpp

Go to the documentation of this file.

#ifndef MIRROR_META_PROG_FOR_EACH_1011291729_HPP
#define MIRROR_META_PROG_FOR_EACH_1011291729_HPP


#include <mirror/meta_prog/range.hpp>
#include <mirror/meta_prog/traits.hpp>
#include <mirror/meta_prog/iter_info.hpp>

MIRROR_NAMESPACE_BEGIN
namespace mp {
namespace aux {

// Implementation of for_each for empty ranges
template <
    typename Functor,
    typename IsFirst,
    typename IsLast
>
void for_each(
    Functor& func,
    range<>,
    IsFirst is_first,
    IsLast is_last
)
{ }

// Implementation of for_each for single element ranges
template <
    typename T,
    typename Functor,
    typename IsFirst,
    typename IsLast
>
void for_each(
    Functor& func,
    range<T>,
    IsFirst is_first,
    IsLast is_last
)
{
    // call the functor on the last element
    func(iteration_info<
        T,
        IsFirst,
        std::true_type
    >());
}

// Implementation of for_each for multi element ranges
template <
    typename T,
    typename ... P,
    typename Functor,
    typename IsFirst,
    typename IsLast
>
void for_each(
    Functor& func,
    range<T, P...>,
    IsFirst is_first,
    IsLast is_last
)
{
    // call the functor on the front element
    func(iteration_info<
        T,
        IsFirst,
        IsLast
    >());
    // move to the rest of the range
    for_each(
        func,
        range<P...>(),
        std::false_type(),
        is_last
    );
}

/* Implementation which tries to use the R type as
 * a range returning meta-function
 */
template <
    typename X,
    typename Functor,
    typename IsFirst,
    typename IsLast
>
void for_each(
    Functor& func,
    X,
    IsFirst is_first,
    IsLast is_last
)
{
    MIRROR_ASSERT_RETURNS_RANGE(X);
    for_each(func, typename X::type(), is_first, is_last);
}

template <class Functor>
struct for_each_ii_remover
{
    Functor& func;

    inline for_each_ii_remover(Functor& f)
     : func(f)
    { }

    template <class IterInfo>
    inline void operator()(IterInfo) const
    {
        func(typename IterInfo::type());
    }
};

} // namespace aux


template <typename Range, typename Functor>
void for_each(Functor func)
{
    aux::for_each_ii_remover<Functor> adapted_func(func);
    aux::for_each(
        adapted_func,
        Range(),
        std::true_type(),
        std::false_type()
    );
}


template <typename Range, typename Functor>
void for_each_ii(Functor func)
{
    aux::for_each(
        func,
        Range(),
        std::true_type(),
        std::false_type()
    );
}


} // namespace mp
MIRROR_NAMESPACE_END

#endif //include guard