cast.h

Go to the documentation of this file.

/*
 *  This file is a part of TiledArray.
 *  Copyright (C) 2016  Virginia Tech
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Justus Calvin
 *  Department of Chemistry, Virginia Tech
 *
 *  cast.h
 *  Jan 10, 2016
 *
 */

#ifndef TILEDARRAY_TILE_INTERFACE_CAST_H__INCLUDED
#define TILEDARRAY_TILE_INTERFACE_CAST_H__INCLUDED

#include "../type_traits.h"
#include "../meta.h"

namespace TiledArray {

  template <typename Result, typename Arg, typename Enabler = void> class Cast;

  namespace tile_interface {

    template <typename Result, typename Arg, typename Enabler>
    class Cast;


    template <typename Result, typename Arg>
    class Cast<Result, Arg,
        std::enable_if_t<detail::has_conversion_operator<
            Arg, madness::Future<Result>>::value ||
            detail::is_convertible<Arg, Result>::value>
    > {

     public:

       typedef Result result_type; 
       typedef Arg argument_type; 
       static const constexpr bool is_nonblocking =
           detail::has_conversion_operator<argument_type,
                                           madness::Future<result_type>>::value;

       // basic type sanity checks
       static_assert(
           std::is_same<result_type, std::decay_t<result_type>>::value,
           "Cast<Result,Arg>: Result must be a non-const non-ref type");
       static_assert(
           std::is_same<argument_type, std::decay_t<argument_type>>::value,
           "Cast<Result,Arg>: Arg must be a non-const non-ref type");
       static_assert(
           detail::has_conversion_operator<
               argument_type, madness::Future<result_type>>::value ||
               detail::is_convertible<argument_type, result_type>::value,
           "Cast<Result,Arg> does not know how to construct Result or "
           "Future<Result> from Arg");

      private:
       template <typename Result_, typename Arg_,
                 typename = std::enable_if_t<detail::is_convertible<
                     std::decay_t<Arg_>, Result_>::value>>
       static auto invoker(Arg_&& arg) {
         auto exec = [](Arg_&& arg) {
           return static_cast<Result_>(std::forward<Arg_>(arg));
         };
         return TiledArray::meta::invoke(exec, arg);
       }
       template <typename Result_, typename Arg_>
       static auto invoker(
           Arg_&& arg,
           std::enable_if_t<detail::has_conversion_operator<
               std::decay_t<Arg_>, madness::Future<Result_>>::value>* =
               nullptr) {
         auto exec = [](Arg_&& arg) {
           return static_cast<madness::Future<Result_>>(std::forward<Arg_>(arg));
         };
         return TiledArray::meta::invoke(exec, std::forward<Arg_>(arg));
       }

      public:

       template <typename Arg_, typename = std::enable_if_t<std::is_same<
                                    argument_type, std::decay_t<Arg_>>::value>>
       auto operator()(Arg_&& arg) const {
         return this->invoker<result_type>(arg);
       }

    }; // class Cast


    template <typename Result, typename Arg>
    class Cast<Result, Arg,
        typename std::enable_if<
            is_lazy_tile<Arg>::value &&
            ! std::is_same<Result, typename TiledArray::eval_trait<Arg>::type>::value
        >::type>
    {
    private:
      typedef typename TiledArray::eval_trait<Arg>::type
          eval_type; 
      typedef TiledArray::Cast<eval_type, Arg>
          arg_to_eval_caster_type; 
      typedef TiledArray::Cast<Result, eval_type>
          eval_to_result_caster_type; 
    public:

      typedef Result result_type; 
      typedef Arg argument_type; 


      template <typename Arg_, typename = std::enable_if_t<std::is_same<
                                   argument_type, std::decay_t<Arg_>>::value>>
      auto operator()(Arg_&& arg) const {
        arg_to_eval_caster_type cast_to_eval;
        eval_to_result_caster_type cast_to_result;
        using TiledArray::meta::invoke;
        return invoke(cast_to_result, invoke(cast_to_eval, arg));
      }

    }; // class Cast

  } // namespace tile_interface



  template <typename Result, typename Arg, typename Enabler>
  class Cast : public TiledArray::tile_interface::Cast<Result, Arg, Enabler> { };

  template <typename Arg, typename Result = typename TiledArray::eval_trait<std::decay_t<Arg>>::type>
  auto invoke_cast(Arg&& arg) {
    Cast<Result,std::decay_t<Arg>> cast;
    return TiledArray::meta::invoke(cast, std::forward<Arg>(arg));
  }

} // namespace TiledArray

#endif // TILEDARRAY_TILE_INTERFACE_CAST_H__INCLUDED