eval.hpp

Go to the documentation of this file.

// Copyright (c) 2024--present, The Simons Foundation
// This file is part of TRIQS/nda and is licensed under the Apache License, Version 2.0.
// SPDX-License-Identifier: Apache-2.0
// See LICENSE in the root of this distribution for details.

 
#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