eval.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 "./expression.hpp"
#include "./operation.hpp"
#include "./placeholder.hpp"
#include "./utils.hpp"
#include "../macros.hpp"
 
#include <functional>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace nda::clef {
 
  // Forward declarations.
  template <typename T, typename... Pairs>
  decltype(auto) eval(T const &obj, Pairs &&...pairs);
 
  template <typename T, typename... Pairs>
  struct evaluator {
    static constexpr bool is_lazy = is_any_lazy<T>;
 
    FORCEINLINE T const &operator()(T const &t, Pairs &...) const { return t; }
  };
 
  template <int N, int... Is, typename... Ts>
  struct evaluator<placeholder<N>, pair<Is, Ts>...> {
    private:
    // Helper function to determine the position of the nda::clef::pair that has the nda::clef::placeholder<N>.
    template <size_t... Ps>
    static constexpr int get_position_of_N(std::index_sequence<Ps...>) {
      return ((Is == N ? int(Ps) + 1 : 0) + ...) - 1;
    }
 
    // The position of the nda::clef::pair that has the nda::clef::placeholder<N> (-1 if no such pair was given).
    static constexpr int N_position = get_position_of_N(std::make_index_sequence<sizeof...(Is)>{});
 
    public:
    static constexpr bool is_lazy = (N_position == -1);
 
    FORCEINLINE decltype(auto) operator()(placeholder<N>, pair<Is, Ts> &...pairs) const {
      if constexpr (not is_lazy) { // N is one of the Is
        auto &pair_N = std::get<N_position>(std::tie(pairs...));
        // the pair is a temporary constructed for the time of the eval call
        // if it holds a reference, we return it, else we move the rhs object out of the pair
        if constexpr (std::is_lvalue_reference_v<decltype(pair_N.rhs)>) {
          return pair_N.rhs;
        } else {
          return std::move(pair_N.rhs);
        }
      } else { // N is not one of the Is
        return placeholder<N>{};
      }
    }
  };
 
  template <typename T, typename... Pairs>
  struct evaluator<std::reference_wrapper<T>, Pairs...> {
    static constexpr bool is_lazy = false;
 
    FORCEINLINE decltype(auto) operator()(std::reference_wrapper<T> const &wrapper, Pairs const &...pairs) const {
      return eval(wrapper.get(), pairs...);
    }
  };
 
  template <typename Tag, typename... Childs, typename... Pairs>
  struct evaluator<expr<Tag, Childs...>, Pairs...> {
    static constexpr bool is_lazy = (evaluator<Childs, Pairs...>::is_lazy or ...);
 
    private:
    // Helper function to evaluate the given expression.
    template <size_t... Is>
    [[nodiscard]] FORCEINLINE decltype(auto) eval_impl(std::index_sequence<Is...>, expr<Tag, Childs...> const &ex, Pairs &...pairs) const {
      return op_dispatch<Tag>(std::integral_constant<bool, is_lazy>{}, eval(std::get<Is>(ex.childs), pairs...)...);
    }
 
    public:
    [[nodiscard]] FORCEINLINE decltype(auto) operator()(expr<Tag, Childs...> const &ex, Pairs &...pairs) const {
      return eval_impl(std::make_index_sequence<sizeof...(Childs)>(), ex, pairs...);
    }
  };
 
  template <typename T, typename... Pairs>
  FORCEINLINE decltype(auto) eval(T const &obj, Pairs &&...pairs) { // NOLINT (we don't want to forward here)
    return evaluator<T, std::remove_reference_t<Pairs>...>()(obj, pairs...);
  }
 
} // namespace nda::clef