ivl/details/core/types/lazy.hpp

/* This file is part of the ivl C++ library <http://image.ntua.gr/ivl>.
   A C++ template library extending syntax towards mathematical notation.

   Copyright (C) 2012 Yannis Avrithis <iavr@image.ntua.gr>
   Copyright (C) 2012 Kimon Kontosis <kimonas@image.ntua.gr>

   ivl is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License 
   version 3 as published by the Free Software Foundation.

   Alternatively, you can redistribute it and/or modify it under the terms 
   of the GNU General Public License version 2 as published by the Free 
   Software Foundation.

   ivl is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
   See the GNU General Public License for more details.

   You should have received a copy of the GNU General Public License 
   and a copy of the GNU Lesser General Public License along 
   with ivl. If not, see <http://www.gnu.org/licenses/>. */

#ifndef IVL_CORE_DETAILS_TYPES_LAZY_HPP
#define IVL_CORE_DETAILS_TYPES_LAZY_HPP

namespace ivl {
namespace types {

// This struct is inherited by all expression classes which are lazy.
// A lazy expression E is computed with typename E::type but is written as E.
struct lazy_expr { };

//
template <int N>
struct arg { };

template <class T>
struct lazy_stop { };

namespace types_details {

template <class T, class IS_LAZY_EXPR>
struct lazy_run_op
{
        typedef T type;
};

template <class T>
struct lazy_run_op<T, t_true>
{
        typedef typename T::type type;
};

} /* namespace types_details */

template <class T>
struct lazy_run
{
        typedef types_details::lazy_run_op lazy_run_op;
        typedef typename lazy_run_op<T, typename is_base<lazy_expr, T>::type>::type
                type;
};

//
template <class T>
struct lazy_type : public lazy_expr { };

template <class T>
struct lazy_run<lazy_type<T> >
{
        typedef typename T::type type;
};

// This type is used to define a lazy expression
template <class E>
struct lazy
{
        template <class T>
        struct eval
        {
                typedef typename lazy_run<E>::type type;
        };
};

template <template <typename> class C, class T1>
struct lazy<lazy_stop<T1> >
{
        typedef T1 type;
};

template <template <typename> class C, class T1>
struct lazy<C<T1> >
{
        template <class T>
        struct eval
        {
                typedef typename lazy_run<C<typename lazy<T1>::eval<T>::type> >::
                        type type;
        };
};

template <template <typename, typename> class C, class T1, class T2>
struct lazy<C<T1, T2> >
{
        template <class T>
        struct eval
        {
                typedef typename lazy_run<C<
                        typename lazy<T1>::eval<T>::type,
                        typename lazy<T2>::eval<T>::type> >::
                        type type;
        };
};

template <template <typename, typename, typename> class C,
        class T1, class T2, class T3>
struct lazy<C<T1, T2, T3> >
{
        template <class T>
        struct eval
        {
                typedef typename lazy_run<C<
                        typename lazy<T1>::eval<T>::type,
                        typename lazy<T2>::eval<T>::type,
                        typename lazy<T3>::eval<T>::type> >::
                        type type;
        };
};

template <int N>
struct lazy<arg<N> >
{
        template <class TPL>
        struct eval
        {
                typedef typename TPL::template val_t<N>::type type;
        };
};

lazy<T<1> >::eval<TPL> => typename lazy_run<T<lazy<1>::eval<TPL> >> >::type
lazy<T<1,2> >::eval<TPL> => typename lazy_run<T<lazy<1>::eval<TPL> >> >::type
lazy<T<1..> >::eval<TPL> => typename lazy_run<T<lazy<1>::eval<TPL> >>>::type
lazy<T<1..,10> >::eval<TPL> => typename lazy_run<T<lazy<1>::eval<TPL> >>>::type

lazy<arg<1> >::eval<TPL> => TPL::t1
lazy<arg<2> >::eval<TPL> => TPL::t2
lazy<arg<..> >::eval<TPL> => TPL::..
lazy<arg<10> >::eval<TPL> => TPL::t10

lazy<E> : typename lazy_run<E>::type

lazy_run<E>
cases:
        is_base<E, lazy_expr>,
        typename E::type,
        E


lazy<lazy_stop<E> >::eval<TPL> => E

is_ivl_array<arg<0> >

A::elem_type

l_elem_type<A>
l_...

lazy<T<2> > => lazy<T<lazy<2> >>


} /* namespace types */
} /* namespace ivl */

#endif // IVL_CORE_DETAILS_TYPES_LAZY_HPP