rubber/rubber.hpp

Go to the documentation of this file.

#ifndef RUBBER_RUBBER_1103151301_HPP
#define RUBBER_RUBBER_1103151301_HPP

#include <rubber/config.hpp>
#include <rubber/wrap.hpp>
#include <rubber/range.hpp>
#include <rubber/specifiers.hpp>
#include <rubber/meta_objects.hpp>
#include <puddle/auxiliary/fwd.hpp>

#include <functional>



RUBBER_NAMESPACE_BEGIN

template <class MirrorMetaObject>
auto erase_type(void) ->
decltype(wrap<MirrorMetaObject>())
{
    return wrap<MirrorMetaObject>();
}

template <class MirrorMetaObject>
auto erase_type(const puddle::aux::meta_type<MirrorMetaObject>& mo) ->
decltype(wrap<MirrorMetaObject>())
{
    return wrap<MirrorMetaObject>();
}

namespace aux {

template <typename ... Wrappers>
class eraser_base;

template <>
class eraser_base<>
{
public:
    template <typename MetaObject>
    void call(const MetaObject& mo) const
    { }
};

template <typename Wrapper, typename ... Wrappers>
class eraser_base<Wrapper, Wrappers ...>
{
private:
    typedef std::function<void(const Wrapper&)> functor_type;
    functor_type functor;
    eraser_base<Wrappers...> base;

    template <typename MetaObject>
    void do_call(const MetaObject& mo, std::false_type) const
    {
        base.call(mo);
    }

    template <typename MetaObject>
    void do_call(const MetaObject& mo, std::true_type) const
    {
        functor(wrap_into<Wrapper>(mo));
    }
public:
    eraser_base(
        const functor_type& func,
        const std::function<void(const Wrappers&)>& ... fns
    ): functor(func)
     , base(fns ...)
    { }

    template <typename MetaObject>
    void call(const MetaObject& mo) const
    {
        typename mirror::mp::is_a<
            MetaObject,
            typename tag_by_wrapper<Wrapper>::type
        >::type selector;
        do_call(mo, selector);
    }
};

} // namespace aux

template <typename ... Wrappers>
class eraser
{
private:
    aux::eraser_base<Wrappers...> base;
public:
    eraser(const std::function<void(const Wrappers&)>& ... fns)
     : base(fns...)
    { }

    template <typename MetaObject>
    void operator()(MetaObject mo) const
    {
        base.call(mo);
    }
};

RUBBER_NAMESPACE_END

#endif //include guard