auto_assign_subscript.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 {

 
  // Delete the generic version so that every supported type has to implement its own version.
  template <typename T, typename RHS>
  FORCEINLINE void clef_auto_assign_subscript(T, RHS) = delete;

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

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

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

  template <typename T, typename RHS, int... Is>
  FORCEINLINE void operator<<(expr<tags::subscript, T, 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_subscript(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::subscript, 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_subscript(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::subscript, 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_subscript(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::subscript, F, T...> &&ex, RHS &&rhs) = delete; // NOLINT (no forwarding required here)
  template <typename F, typename RHS, typename... T>
  void operator<<(expr<tags::subscript, F, T...> &ex, RHS &&rhs) = delete; // NOLINT (no forwarding required here)
  template <typename F, typename RHS, typename... T>
  void operator<<(expr<tags::subscript, F, T...> const &ex, RHS &&rhs) = delete; // NOLINT (no forwarding required here)

 
} // namespace nda::clef