functional.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
#ifndef dealii_cxx20_functional_h
#define dealii_cxx20_functional_h
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_HAVE_CXX20
#  include <functional>
#else
#  include <functional>
#  include <tuple>
#  include <utility>
#endif
 
DEAL_II_NAMESPACE_OPEN
 
namespace std_cxx20
{
#ifndef DEAL_II_HAVE_CXX20
#  ifndef DOXYGEN
 
  namespace internal
  {
    template <typename F,
              size_t... Ind,
              typename BoundArgsTuple,
              typename... CallArgs>
    constexpr decltype(auto)
    call_bind(F &&function,
              std::index_sequence<Ind...>,
              BoundArgsTuple &&bound_args,
              CallArgs &&...call_args)
    {
      return std::invoke(std::forward<F>(function),
                         std::get<Ind>(
                           std::forward<BoundArgsTuple>(bound_args))...,
                         std::forward<CallArgs>(call_args)...);
    }
 
    template <typename F, typename... BoundArgs>
    decltype(auto)
    make_bind_front(F &&f, BoundArgs &&...bound_args)
    {
      return [f          = std::forward<F>(f),
              bound_args = std::make_tuple(
                std::forward<BoundArgs>(bound_args)...)](auto &&...call_args) {
        // Perform actual call inside a helper functions which allows to use
        // pattern-matching to the index sequence.
        return call_bind(f,
                         std::index_sequence_for<BoundArgs...>{},
                         bound_args,
                         std::forward<decltype(call_args)>(call_args)...);
      };
    }
 
  } // namespace internal
 
#  endif
 
  template <typename F, typename... BoundArgs>
  decltype(auto)
  bind_front(F &&f, BoundArgs &&...bound_args)
  {
    return internal::make_bind_front(std::forward<F>(f),
                                     std::forward<BoundArgs>(bound_args)...);
  }
#else
  using std::bind_front;
#endif
 
} // namespace std_cxx20
 
DEAL_II_NAMESPACE_CLOSE
 
#endif