mutable_bind.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2019 - 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_base_mutable_bind_h
#define dealii_base_mutable_bind_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/patterns.h>
 
#include <tuple>
#include <utility>
 
DEAL_II_NAMESPACE_OPEN
 
namespace Utilities
{
  template <typename ReturnType, class... FunctionArgs>
  class MutableBind
  {
  public:
    using TupleType =
      std::tuple<std::remove_cv_t<std::remove_reference_t<FunctionArgs>>...>;
 
    template <typename FunctionType>
    MutableBind(FunctionType function, FunctionArgs &&...arguments);
 
    template <typename FunctionType>
    MutableBind(FunctionType function, TupleType &&arguments);
 
    template <typename FunctionType>
    MutableBind(FunctionType function);
 
    ReturnType
    operator()() const;
 
    void
    set_arguments(TupleType &&arguments);
 
    void
    set_arguments(FunctionArgs &&...arguments);
 
    void
    parse_arguments(const std::string           &value_string,
                    const Patterns::PatternBase &pattern =
                      *Patterns::Tools::Convert<TupleType>::to_pattern());
 
  private:
    const std::function<ReturnType(FunctionArgs...)> function;
 
    TupleType arguments;
  };
 
 
 
  template <typename ReturnType, class... FunctionArgs>
  MutableBind<ReturnType, FunctionArgs...>
  mutable_bind(ReturnType (*function)(FunctionArgs...),
               std_cxx20::type_identity_t<FunctionArgs> &&...arguments);
 
  template <typename ReturnType, class... FunctionArgs>
  MutableBind<ReturnType, FunctionArgs...>
  mutable_bind(std::function<ReturnType(FunctionArgs...)>,
               std_cxx20::type_identity_t<FunctionArgs> &&...arguments);
 
  template <typename ReturnType, class... FunctionArgs>
  MutableBind<ReturnType, FunctionArgs...>
    mutable_bind(ReturnType (*function)(FunctionArgs...));
 
  template <typename ReturnType, class... FunctionArgs>
  MutableBind<ReturnType, FunctionArgs...>
    mutable_bind(std::function<ReturnType(FunctionArgs...)>);
 
 
 
#ifndef DOXYGEN
  template <typename ReturnType, class... FunctionArgs>
  template <typename FunctionType>
  MutableBind<ReturnType, FunctionArgs...>::MutableBind(
    FunctionType function,
    FunctionArgs &&...arguments)
    : function(function)
    , arguments(std::make_tuple(std::move(arguments)...))
  {}
 
 
 
  template <typename ReturnType, class... FunctionArgs>
  template <typename FunctionType>
  MutableBind<ReturnType, FunctionArgs...>::MutableBind(FunctionType function,
                                                        TupleType  &&arguments)
    : function(function)
    , arguments(std::move(arguments))
  {}
 
 
 
  template <typename ReturnType, class... FunctionArgs>
  template <typename FunctionType>
  MutableBind<ReturnType, FunctionArgs...>::MutableBind(FunctionType function)
    : function(function)
  {}
 
 
 
  template <typename ReturnType, class... FunctionArgs>
  ReturnType
  MutableBind<ReturnType, FunctionArgs...>::operator()() const
  {
    return std::apply(function, arguments);
  }
 
 
 
  template <typename ReturnType, class... FunctionArgs>
  void
  MutableBind<ReturnType, FunctionArgs...>::set_arguments(
    FunctionArgs &&...args)
  {
    arguments = std::make_tuple(std::move(args)...);
  }
 
 
 
  template <typename ReturnType, class... FunctionArgs>
  void
  MutableBind<ReturnType, FunctionArgs...>::set_arguments(TupleType &&args)
  {
    arguments = std::move(args);
  }
 
 
 
  template <typename ReturnType, class... FunctionArgs>
  void
  MutableBind<ReturnType, FunctionArgs...>::parse_arguments(
    const std::string           &value_string,
    const Patterns::PatternBase &pattern)
  {
    arguments =
      Patterns::Tools::Convert<TupleType>::to_value(value_string, pattern);
  }
 
 
 
  template <typename ReturnType, class... FunctionArgs>
  MutableBind<ReturnType, FunctionArgs...>
  mutable_bind(ReturnType (*function)(FunctionArgs...),
               std_cxx20::type_identity_t<FunctionArgs> &&...arguments)
  {
    return MutableBind<ReturnType, FunctionArgs...>(function,
                                                    std::move(arguments)...);
  }
 
 
 
  template <typename ReturnType, class... FunctionArgs>
  MutableBind<ReturnType, FunctionArgs...>
  mutable_bind(ReturnType (*function)(FunctionArgs...))
  {
    return MutableBind<ReturnType, FunctionArgs...>(function);
  }
 
 
 
  template <typename ReturnType, class... FunctionArgs>
  MutableBind<ReturnType, FunctionArgs...>
  mutable_bind(std::function<ReturnType(FunctionArgs...)> function,
               std_cxx20::type_identity_t<FunctionArgs> &&...arguments)
  {
    return MutableBind<ReturnType, FunctionArgs...>(function,
                                                    std::move(arguments)...);
  }
 
 
 
  template <typename ReturnType, class... FunctionArgs>
  MutableBind<ReturnType, FunctionArgs...>
  mutable_bind(std::function<ReturnType(FunctionArgs...)> function)
  {
    return MutableBind<ReturnType, FunctionArgs...>(function);
  }
#endif
} // namespace Utilities
 
DEAL_II_NAMESPACE_CLOSE
 
#endif