rubber/range.hpp

Go to the documentation of this file.

#ifndef RUBBER_RANGE_1103151301_HPP
#define RUBBER_RANGE_1103151301_HPP

#include <rubber/config.hpp>
#include <rubber/wrap.hpp>

#include <mirror/meta_prog/range.hpp>

#include <vector>
#include <functional>

RUBBER_NAMESPACE_BEGIN

template <typename TypeErased>
class range;


struct iteration_info
{
    bool is_first;
    bool is_last;
};


template <typename TypeErased>
class range
{
private:
    typedef typename aux::return_value<TypeErased>::type
    (*member_getter)(void);

    const std::vector<member_getter>& getters;
    typename std::vector<member_getter>::const_iterator pos;
public:
    range(const std::vector<member_getter>& _getters)
     : getters(_getters)
     , pos(getters.begin())
    { }

    inline bool empty(void) const
    {
        return getters.end() == pos;
    }

    inline size_t size(void) const
    {
        return getters.end() - pos;
    }

    #ifdef MIRROR_DOCUMENTATION_ONLY

    TypeErased front(void) const;
    #else
    inline typename aux::return_value<TypeErased>::type front(void) const
    {
        assert(!empty());
        return (*pos)();
    }
    #endif

    #ifdef MIRROR_DOCUMENTATION_ONLY

    TypeErased at(size_t index) const;
    #else
    inline typename aux::return_value<TypeErased>::type at(size_t idx) const
    {
        assert(idx < size());
        return (*(pos + idx))();
    }
    #endif

    inline void step_front(void)
    {
        assert(!empty());
        ++pos;
    }

    void for_each(const std::function<void(const TypeErased&)>& func) const
    {
        if(!empty())
        {
            range tmp = *this;
            while(!tmp.empty())
            {
                func(tmp.front());
                tmp.step_front();
            }
        }
    }


    void for_each_ii(
        const std::function<
            void(const TypeErased&, const iteration_info&)
        >& func
    ) const
    {
        if(!empty())
        {
            auto tmp_pos = pos;
            auto tmp_get = *tmp_pos;
            ++tmp_pos;
            struct iteration_info iter_info = {
                true,
                tmp_pos == getters.end()
            };
            func(tmp_get(), iter_info);
            iter_info.is_first = false;
            while(tmp_pos != getters.end())
            {
                tmp_get = *tmp_pos;
                ++tmp_pos;
                iter_info.is_last = tmp_pos == getters.end();
                func(tmp_get(), iter_info);
            }
        }
    }
};

template <class TypeErased>
class range_holder
{
private:
    typedef typename aux::return_value<TypeErased>::type
    (*getter)(void);

    std::vector<getter> _getters;

    template <typename ... MetaObjects>
    static std::vector<getter> init_getters(
        mirror::mp::range<MetaObjects...>
    )
    {
        return {&wrap_shaped<MetaObjects, TypeErased>...};
    }
public:
    template <template <class> class Getter, class MetaObject>
    range_holder(Getter<MetaObject>)
     : _getters(
        init_getters(
            typename mirror::mp::as_range<
                Getter<MetaObject>
            >::type()
        )
    )
    { }

    range_holder(mirror::mp::empty_range)
    { }

    range<TypeErased> all(void) const
    {
        return range<TypeErased>(_getters);
    }
};

RUBBER_NAMESPACE_END

#endif //include guard