expression.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 "./utils.hpp"
 
#include <tuple>
#include <utility>
 
namespace nda::clef {
 
  namespace tags {


    struct function {};

    struct subscript {};

    struct terminal {};

    struct if_else {};

    struct unary_op {};

    struct binary_op {};

 
  } // namespace tags


  template <typename Tag, typename... Ts>
  struct expr {
    using childs_t = std::tuple<Ts...>;

    childs_t childs;

    expr(expr const &) = default;

    expr(expr &&ex) noexcept : childs(std::move(ex.childs)) {}

    expr &operator=(expr const &) = delete;

    expr &operator=(expr &&) = default;

    template <typename... Us>
    expr(Tag, Us &&...us) : childs(std::forward<Us>(us)...) {}

#ifdef __cpp_explicit_this_parameter
    template <typename Self, typename... Args>
    auto operator[](this Self &&self, Args &&...args) {
      return expr<tags::subscript, expr, expr_storage_t<Args>...>{tags::subscript(), std::forward<Self>(self), std::forward<Args>(args)...};
    }
#else
    template <typename... Args>
    auto operator[](Args &&...args) const & {
      return expr<tags::subscript, expr, expr_storage_t<Args>...>{tags::subscript(), *this, std::forward<Args>(args)...};
    }
    template <typename... Args>
    auto operator[](Args &&...args) & {
      return expr<tags::subscript, expr, expr_storage_t<Args>...>{tags::subscript(), *this, std::forward<Args>(args)...};
    }
 
    template <typename... Args>
    auto operator[](Args &&...args) && {
      return expr<tags::subscript, expr, expr_storage_t<Args>...>{tags::subscript(), std::move(*this), std::forward<Args>(args)...};
    }
#endif

#ifdef __cpp_explicit_this_parameter
    template <typename Self, typename... Args>
    auto operator()(this Self &&self, Args &&...args) {
      return expr<tags::function, expr, expr_storage_t<Args>...>{tags::function(), std::forward<Self>(self), std::forward<Args>(args)...};
    }
#else
    template <typename... Args>
    auto operator()(Args &&...args) const & {
      return expr<tags::function, expr, expr_storage_t<Args>...>{tags::function(), *this, std::forward<Args>(args)...};
    }
 
    template <typename... Args>
    auto operator()(Args &&...args) & {
      return expr<tags::function, expr, expr_storage_t<Args>...>{tags::function(), *this, std::forward<Args>(args)...};
    }
 
    template <typename... Args>
    auto operator()(Args &&...args) && {
      return expr<tags::function, expr, expr_storage_t<Args>...>{tags::function(), std::move(*this), std::forward<Args>(args)...};
    }
#endif
  };
 
  namespace detail {
 
    // Specialization of ph_set for nda::clef::expr types.
    template <typename Tag, typename... Ts>
    struct ph_set<expr<Tag, Ts...>> : ph_set<Ts...> {};
 
    // Specialization of is_lazy_impl for nda::clef::expr types (always true).
    template <typename Tag, typename... Ts>
    constexpr bool is_lazy_impl<expr<Tag, Ts...>> = true;
 
    // Specialization of force_copy_in_expr_impl for nda::clef::expr types (always true).
    template <typename Tag, typename... Ts>
    constexpr bool force_copy_in_expr_impl<expr<Tag, Ts...>> = true;
 
  } // namespace detail

 
} // namespace nda::clef