mutable_bind.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2019 - 2020 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.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 <deal.II/base/std_cxx14/utility.h>
#include <deal.II/base/std_cxx17/tuple.h>

#include <tuple>

DEAL_II_NAMESPACE_OPEN

namespace Utilities
{
  template <typename ReturnType, class... FunctionArgs>
  class MutableBind
  {
  public:
    using TupleType = std::tuple<typename std::remove_cv<
      typename std::remove_reference<FunctionArgs>::type>::type...>;

    template <class FunctionType>
    MutableBind(FunctionType function, FunctionArgs &&... arguments);

    template <class FunctionType>
    MutableBind(FunctionType function, TupleType &&arguments);

    template <class 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 std::unique_ptr<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...),
               typename identity<FunctionArgs>::type &&... arguments);

  template <typename ReturnType, class... FunctionArgs>
  MutableBind<ReturnType, FunctionArgs...>
  mutable_bind(std::function<ReturnType(FunctionArgs...)>,
               typename identity<FunctionArgs>::type &&... 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 <class FunctionType>
  MutableBind<ReturnType, FunctionArgs...>::MutableBind(
    FunctionType function,
    FunctionArgs &&... arguments)
    : function(function)
    , arguments(std::make_tuple(std::move(arguments)...))
  {}



  template <typename ReturnType, class... FunctionArgs>
  template <class FunctionType>
  MutableBind<ReturnType, FunctionArgs...>::MutableBind(FunctionType function,
                                                        TupleType && arguments)
    : function(function)
    , arguments(std::move(arguments))
  {}



  template <typename ReturnType, class... FunctionArgs>
  template <class FunctionType>
  MutableBind<ReturnType, FunctionArgs...>::MutableBind(FunctionType function)
    : function(function)
  {}



  template <typename ReturnType, class... FunctionArgs>
  ReturnType
  MutableBind<ReturnType, FunctionArgs...>::operator()() const
  {
    return std_cxx17::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 std::unique_ptr<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...),
               typename identity<FunctionArgs>::type &&... 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,
               typename identity<FunctionArgs>::type &&... 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