unary_wrapper.h

Go to the documentation of this file.

/*
 *  This file is a part of TiledArray.
 *  Copyright (C) 2013  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
 *
 *  binary_interface.h
 *  Oct 6, 2013
 *
 */
 
#ifndef TILEDARRAY_TILE_OP_UNARY_WRAPPER_H__INCLUDED
#define TILEDARRAY_TILE_OP_UNARY_WRAPPER_H__INCLUDED
 
#include <TiledArray/permutation.h>
#include <TiledArray/tile_op/tile_interface.h>
#include <TiledArray/zero_tensor.h>
 
namespace TiledArray {
namespace detail {
 
 
template <typename Op>
class UnaryWrapper {
 public:
  typedef UnaryWrapper<Op> UnaryWrapper_;
  typedef typename Op::argument_type argument_type;  
  typedef typename Op::result_type result_type;      
 
  static constexpr bool is_consumable = Op::is_consumable;
 
  template <typename T>
  static constexpr bool is_lazy_tile_v = is_lazy_tile<std::decay_t<T>>::value;
 
  template <typename T>
  static constexpr bool is_array_tile_v = is_array_tile<std::decay_t<T>>::value;
 
  template <typename T>
  static constexpr bool is_nonarray_lazy_tile_v =
      is_lazy_tile_v<T> && !is_array_tile_v<T>;
 
  template <typename T>
  using eval_t = typename eval_trait<std::decay_t<T>>::type;
 
 private:
  Op op_;                      
  BipartitePermutation perm_;  
 
 public:
  // Compiler generated functions
  UnaryWrapper(const UnaryWrapper_&) = default;
  UnaryWrapper(UnaryWrapper_&&) = default;
  ~UnaryWrapper() = default;
  UnaryWrapper_& operator=(const UnaryWrapper_&) = default;
  UnaryWrapper_& operator=(UnaryWrapper_&&) = default;
 
  UnaryWrapper(const Op& op, const BipartitePermutation& perm)
      : op_(op), perm_(perm) {}
 
  UnaryWrapper(const Op& op) : op_(op), perm_() {}
 
 
  const BipartitePermutation& permutation() const { return perm_; }
 
 
  auto operator()(argument_type& arg) const {
    return (perm_ ? op_(arg, perm_) : op_(arg));
  }
 
 
  auto operator()(const argument_type& arg) const {
    return (perm_ ? op_(arg, perm_) : op_(arg));
  }
 
 
  template <typename A, std::enable_if_t<is_nonarray_lazy_tile_v<A>>* = nullptr>
  auto operator()(A&& arg) const {
    return (perm_ ? meta::invoke(op_, invoke_cast(std::forward<A>(arg)), perm_)
                  : meta::invoke(op_, invoke_cast(std::forward<A>(arg))));
  }
 
 
  template <typename A, std::enable_if_t<is_array_tile_v<A>>* = nullptr>
  auto operator()(A&& arg) const {
    auto cast_arg = invoke_cast(std::forward<A>(arg));
    // TODO replace with generic lambda, replace cast_arg with
    // std::move(cast_arg)
    //        NB using this generic lambda breaks TaskFn ...
    //        need to make TaskFn variadic and accepting callables, but this is
    //        a lot of MP
    //
    //        auto op_consume = [this](auto&& arg) {
    //          return op_.consume(std::forward<decltype(arg)>(arg));
    //        };
    auto op_consume = [this](eval_t<A>& arg) { return op_.consume(arg); };
    return (perm_ ? meta::invoke(op_, std::move(cast_arg), perm_)
                  : (arg.is_consumable()
                         ? meta::invoke(op_consume, cast_arg)
                         : meta::invoke(op_, std::move(cast_arg))));
  }
 
  template <typename A, std::enable_if_t<is_lazy_tile_v<A>>* = nullptr>
  auto consume(A&& arg) const {
    auto cast_arg = invoke_cast(std::forward<A>(arg));
    // TODO replace with generic lambda, replace cast_arg with
    // std::move(cast_arg)
    //        NB using this generic lambda breaks TaskFn ...
    //        need to make TaskFn variadic and accepting callables, but this is
    //        a lot of MP
    //
    //        auto op_consume = [this](auto&& arg) {
    //          return op_.consume(std::forward<decltype(arg)>(arg));
    //        };
    auto op_consume = [this](eval_t<A>& arg) { return op_.consume(arg); };
    return (perm_ ? meta::invoke(op_, std::move(cast_arg), perm_)
                  : meta::invoke(op_consume, cast_arg));
  }
 
  template <typename A, std::enable_if_t<!is_lazy_tile_v<A>>* = nullptr>
  result_type consume(A&& arg) const {
    static_assert(std::is_same<std::decay_t<A>, argument_type>::value,
                  "UnaryWrapper::consume(A&&): invalid argument type A");
    return (perm_ ? op_(std::forward<A>(arg), perm_)
                  : op_.consume(std::forward<A>(arg)));
  }
 
};  // class UnaryWrapper
 
}  // namespace detail
}  // namespace TiledArray
 
#endif  // TILEDARRAY_TILE_OP_UNARY_WRAPPER_H__INCLUDED