function.hpp

Go to the documentation of this file.

// Copyright (c) 2024 Simons Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0.txt
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Authors: Thomas Hahn
 
#pragma once
 
#include "./eval.hpp"
#include "./utils.hpp"
#include "./placeholder.hpp"
#include "../macros.hpp"
 
#include <type_traits>
#include <utility>
 
namespace nda::clef {
 
  template <typename T, int... Is>
  struct make_fun_impl {
    T obj;
 
    template <typename... Args>
    FORCEINLINE decltype(auto) operator()(Args &&...args) const {
      return eval(obj, pair<Is, Args>{std::forward<Args>(args)}...);
    }
  };
 
  template <typename T, typename... Phs>
  FORCEINLINE auto make_function(T &&obj, Phs...) {
    return make_fun_impl<std::decay_t<T>, Phs::index...>{std::forward<T>(obj)};
  }
 
  template <typename T, int... Is, typename... Pairs>
  struct evaluator<make_fun_impl<T, Is...>, Pairs...> {
    using e_t = evaluator<T, Pairs...>;
 
    static constexpr bool is_lazy = (detail::ph_set<make_fun_impl<T, Is...>>::value != detail::ph_set<Pairs...>::value);
 
    FORCEINLINE decltype(auto) operator()(make_fun_impl<T, Is...> const &f, Pairs &...pairs) const {
      return make_function(e_t()(f.obj, pairs...), placeholder<Is>()...);
    }
  };
 
  namespace detail {
 
    // Specialization of is_function_impl for nda::clef::make_fun_impl types.
    template <typename Expr, int... Is>
    inline constexpr bool is_function_impl<make_fun_impl<Expr, Is...>> = true;
 
    // Specialization of ph_set for nda::clef::make_fun_impl types.
    template <typename Expr, int... Is>
    struct ph_set<make_fun_impl<Expr, Is...>> {
      static constexpr ull_t value = ph_filter<ph_set<Expr>::value, Is...>::value;
    };
 
    // Specialization of is_lazy_impl for nda::clef::make_fun_impl types.
    template <typename Expr, int... Is>
    constexpr bool is_lazy_impl<make_fun_impl<Expr, Is...>> = (ph_set<make_fun_impl<Expr, Is...>>::value != 0);
 
    // Specialization of force_copy_in_expr_impl for nda::clef::make_fun_impl types (always true).
    template <typename Expr, int... Is>
    constexpr bool force_copy_in_expr_impl<make_fun_impl<Expr, Is...>> = true;
 
  } // namespace detail
 
} // namespace nda::clef