ivl/details/core/keyword_operators/rval.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_OPERATION_RVAL_HPP
#define IVL_CORE_DETAILS_OPERATION_RVAL_HPP

namespace ivl {

namespace core_details {

template <class A, class DST>
struct rval_tool
{
        typedef DST type;
        static inline type operate(const A& a) { return type(a); }
};

template <class A>
struct rval_tool<A, A>
{
        typedef const A& type;
        static inline const A& operate(const A& a) { return a; }
};

template <class A>
struct resolve_rval
: public rval_tool<A,
//typename types::
//      change_data_class_set_rec<data::normal, A>::type
        typename A::create_new
>
{
        typedef typename resolve_rval::type type;
};

/*
template <class A, class IS_LINEAR>
struct rval_tool {};

template <class A>
struct rval_tool<A, types::t_false>
{
        typedef typename A::create_similar type;
        static inline type operate(const A& a) { return type(a); }
};

template <class A>
struct rval_tool<A, types::t_true>
{
        typedef const A& type;
        static inline const A& operate(const A& a) { return a; }
};

template <class A>
struct resolve_rval
: public rval_tool<A, typename A::is_linear>
{
        typedef typename resolve_rval::type type;
};
*/
/*
template <class A>
struct resolve_is_subreference
: public rval_tool<A, typename types::t_and<typename A::is_writeable,
        types::is_base<types::subreference_identifier, A> >::type>
{
        typedef typename resolve_rval::type type;
};
*/

} /* namespace core_details */

template<class A>
typename core_details::resolve_rval<A>::type rval(const A& a)
{
        return core_details::resolve_rval<A>::operate(a);
}

}; /*namespace ivl*/

#endif // IVL_CORE_DETAILS_OPERATION_RVAL_HPP