mirror/meta_prog/range.hpp

Go to the documentation of this file.

#ifndef MIRROR_META_PROG_RANGE_1011291729_HPP
#define MIRROR_META_PROG_RANGE_1011291729_HPP

#include <mirror/meta_prog/forward_decl.hpp>
#include <mirror/meta_prog/traits.hpp>

MIRROR_NAMESPACE_BEGIN
namespace mp {


template <typename ... P>
struct range
{
    typedef range type;
};

typedef range<> empty_range;

#ifdef MIRROR_DOCUMENTATION_ONLY


template <typename Range>
struct empty { };
#else
// The default implementation of the empty meta-function
template <typename X>
struct empty : empty<typename X::type>::type
{
    MIRROR_ASSERT_RETURNS_RANGE(X);
};
#endif

template <>
struct empty<range<> >
 : std::true_type
{ };

template <typename ... P>
struct empty<range<P...> >
 : std::false_type
{ };

#ifdef MIRROR_DOCUMENTATION_ONLY


template <typename Range>
struct size { };
#else
template <typename X>
struct size : size<typename X::type>::type
{
    MIRROR_ASSERT_RETURNS_RANGE(X);
};
#endif

template <>
struct size<range<> >
 : std::integral_constant<int, 0>
{ };

template <typename T>
struct size<range<T> >
 : std::integral_constant<int, 1>
{ };

template <typename T, typename ... P>
struct size<range<T, P...> >
 : std::integral_constant<int, 1 + size<range<P...> >::value>
{ };

#ifdef MIRROR_DOCUMENTATION_ONLY


template <typename Range>
struct front
{
    typedef unspecified_type type;
};
#else
template <typename X>
struct front
{
    MIRROR_ASSERT_RETURNS_RANGE(X);
    typedef typename front<typename X::type>::type type;
};
#endif

template <typename T, typename ... P>
struct front<range<T, P...> >
{
    typedef T type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <typename BiDiRange>
struct back
{
    typedef unspecified_type type;
};
#else
template <typename X>
struct back
{
    MIRROR_ASSERT_RETURNS_RANGE(X);
    typedef typename back<typename X::type>::type type;
};
#endif

template <typename ... P, typename T>
struct back<range<P..., T> >
{
    typedef T type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <typename Range, int Index>
struct at_c
{
    typedef unspecified_type type;
};
#else
template <typename X, int Index>
struct at_c
{
    MIRROR_ASSERT_RETURNS_RANGE(X);
    typedef typename at_c<typename X::type, Index>::type type;
};
#endif

template <typename T, typename ... P>
struct at_c<range<T, P...>, 0>
{
    typedef T type;
};

template <typename T, typename ... P, int Index>
struct at_c<range<T, P...>, Index>
{
    typedef typename at_c<range<P...>, Index-1>::type type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <typename Range, class Index>
struct at
{
    typedef unspecified_type type;
};
#else
template <typename Range, class Index>
struct at : at_c<Range, Index::value>
{ };
#endif

#ifdef MIRROR_DOCUMENTATION_ONLY


template <typename Range>
struct step_front
{
    typedef unspecified_type type;
};
#else
template <typename X>
struct step_front
{
    MIRROR_ASSERT_RETURNS_RANGE(X);
    typedef typename step_front<
        typename X::type
    >::type type;
};
#endif

template <typename T, typename ... P>
struct step_front<range<T, P...> >
{
    typedef range<P...> type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <typename Range, typename Item>
struct push_back
{
    typedef Range type;
};
#else
template <typename X, typename Item>
struct push_back
{
    MIRROR_ASSERT_RETURNS_RANGE(X);
    typedef typename push_back<
        typename X::type,
        Item
    >::type type;
};
#endif

template <typename ... P, typename Item>
struct push_back<range<P...>, Item>
{
    typedef range<P..., Item> type;
};

namespace aux {

template <typename Expr, typename IsRange>
struct as_range;

template <typename Range>
struct as_range<Range, std::true_type>
{
    typedef Range type;
};

template <typename Expr>
struct as_range<Expr, std::false_type>
{
    MIRROR_ASSERT_RETURNS_RANGE(Expr);
    typedef typename Expr::type type;
};

} // namespace aux

template <typename Expr>
struct as_range : public aux::as_range<
    Expr,
    typename is_range<Expr>::type
>{ };


} // namespace mp
MIRROR_NAMESPACE_END

#endif //include guard