auto_assign.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 "./function.hpp"
#include "./utils.hpp"
#include "./placeholder.hpp"
#include "../macros.hpp"
 
#include <functional>
#include <tuple>
#include <utility>
 
namespace nda::clef {


  template <typename T, typename RHS>
  FORCEINLINE void clef_auto_assign(std::reference_wrapper<T> wrapper, RHS &&rhs) {
    clef_auto_assign(wrapper.get(), std::forward<RHS>(rhs));
  }

  template <typename T, typename RHS>
  FORCEINLINE void clef_auto_assign(expr<tags::terminal, T> const &ex, RHS &&rhs) {
    clef_auto_assign(std::get<0>(ex.childs), std::forward<RHS>(rhs));
  }

  template <typename Tag, typename... Childs, typename RHS>
  FORCEINLINE void clef_auto_assign(expr<Tag, Childs...> const &ex, RHS const &rhs) {
    ex << rhs;
  }
 
  // Overload of `clef_auto_assign` for rvalue references of generic expressions.
  template <typename Tag, typename... Childs, typename RHS>
  FORCEINLINE void clef_auto_assign(expr<Tag, Childs...> &&ex, RHS const &rhs) { // NOLINT (is the rvalue reference overload needed?)
    ex << rhs;
  }

  template <typename F, typename RHS, int... Is>
  FORCEINLINE void operator<<(expr<tags::function, F, placeholder<Is>...> const &ex, RHS &&rhs) {
    static_assert(detail::all_different(Is...), "Error in clef operator<<: Two of the placeholders on the LHS are the same");
    clef_auto_assign(std::get<0>(ex.childs), make_function(std::forward<RHS>(rhs), placeholder<Is>()...));
  }
 
  // Overload of nda::clef::operator<< for rvalue reference expressions.
  template <typename F, typename RHS, int... Is>
  FORCEINLINE void operator<<(expr<tags::function, F, placeholder<Is>...> &&ex, RHS &&rhs) { // NOLINT (is the rvalue reference overload needed?)
    static_assert(detail::all_different(Is...), "Error in clef operator<<: Two of the placeholders on the LHS are the same");
    clef_auto_assign(std::get<0>(ex.childs), make_function(std::forward<RHS>(rhs), placeholder<Is>()...));
  }
 
  // Overload of nda::clef::operator<< for lvalue reference expressions.
  template <typename F, typename RHS, int... Is>
  FORCEINLINE void operator<<(expr<tags::function, F, placeholder<Is>...> &ex, RHS &&rhs) {
    static_assert(detail::all_different(Is...), "Error in clef operator<<: Two of the placeholders on the LHS are the same");
    clef_auto_assign(std::get<0>(ex.childs), make_function(std::forward<RHS>(rhs), placeholder<Is>()...));
  }
 
  // Delete functions to avoid nonsensical cases, e.g. f(x_ + y_) << RHS.
  template <typename F, typename RHS, typename... T>
  void operator<<(expr<tags::function, F, T...> &&ex, RHS &&rhs) = delete; // NOLINT (no forwarding required here)
  template <typename F, typename RHS, typename... T>
  void operator<<(expr<tags::function, F, T...> &ex, RHS &&rhs) = delete; // NOLINT (no forwarding required here)
  template <typename F, typename RHS, typename... T>
  void operator<<(expr<tags::function, F, T...> const &ex, RHS &&rhs) = delete; // NOLINT (no forwarding required here)

 
} // namespace nda::clef