Utilities::MutableBind< ReturnType, FunctionArgs > Class Template Reference

#include <deal.II/base/mutable_bind.h>

Public Types
using	TupleType

Public Member Functions
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 Attributes
const std::function< ReturnType(FunctionArgs...)>	function
TupleType	arguments

Detailed Description

template<typename ReturnType, class... FunctionArgs>
class Utilities::MutableBind< ReturnType, FunctionArgs >

A mutable version of std::bind, that binds all arguments of a function pointer to a stored tuple, and allows you to update the tuple between calls.

An example usage of this class is through the helper function mutable_bind() that creates a MutableBind object on the fly, based on its arguments:

void my_function(const int &a, const double &b);
 
auto bound = mutable_bind(my_function, 1, 2.0);
 
bound(); // will execute my_function(1, 2.0);
 
bound.set_arguments(2, 3.0);
bound(); // will execute my_function(2, 3.0);
 
bound.parse_arguments("3: 4.0");
bound(); // will execute my_function(3, 4.0);

The arguments are copied to the tuple, with their reference and const attributes removed. Only copy constructible objects are allowed as function arguments. If you need to keep some references around, you may wrap your function into a lambda function:

void
example_function(const Point<2> &p,
                 const double &d,
                 const unsigned int i = 3) {
...
};
 
const Point<2> p(1, 2);
 
Utilities::MutableBind<void, double, unsigned int> exp = {
  [&p](const double &d,
       const unsigned int i)
  {
    example_function(p, d, i);
  },
  {}};
 
exp.parse_arguments("3.0 : 4");
exp(); // calls example_function(p, 3.0, 4);

Definition at line 80 of file mutable_bind.h.

Member Typedef Documentation

TupleType

template<typename ReturnType , class... FunctionArgs>

using Utilities::MutableBind< ReturnType, FunctionArgs >::TupleType

Initial value:

 
      std::tuple<std::remove_cv_t<std::remove_reference_t<FunctionArgs>>...>

An alias to the stored std::tuple type. Only copy constructible objects are allowed as tuple members.

Definition at line 87 of file mutable_bind.h.

Constructor & Destructor Documentation

MutableBind() [1/3]

template<typename ReturnType , class... FunctionArgs>

template<typename FunctionType >

Utilities::MutableBind< ReturnType, FunctionArgs >::MutableBind	(	FunctionType	function,
		FunctionArgs &&...	arguments )

Construct a MutableBind object specifying the function, and each arguments separately.

MutableBind() [2/3]

template<typename ReturnType , class... FunctionArgs>

template<typename FunctionType >

Utilities::MutableBind< ReturnType, FunctionArgs >::MutableBind	(	FunctionType	function,
		TupleType &&	arguments )

Construct a MutableBind object specifying the function, and the arguments as a tuple.

MutableBind() [3/3]

template<typename ReturnType , class... FunctionArgs>

template<typename FunctionType >

Utilities::MutableBind< ReturnType, FunctionArgs >::MutableBind

(

FunctionType

function

)

Construct a MutableBind object specifying only the function. By default, the arguments are left to their default constructor values.

Member Function Documentation

operator()()

template<typename ReturnType , class... FunctionArgs>

ReturnType Utilities::MutableBind< ReturnType, FunctionArgs >::operator()

(

)

const

Call the original function, passing as arguments the elements of the tuple of bound arguments.

set_arguments() [1/2]

template<typename ReturnType , class... FunctionArgs>

void Utilities::MutableBind< ReturnType, FunctionArgs >::set_arguments

(

TupleType &&

arguments

)

Set the arguments to use in function, for next time operator()() is called, using move semantic.

set_arguments() [2/2]

template<typename ReturnType , class... FunctionArgs>

void Utilities::MutableBind< ReturnType, FunctionArgs >::set_arguments

(

FunctionArgs &&...

arguments

)

Set the arguments to use in function, for next time operator()() is called, using move semantic.

parse_arguments()

template<typename ReturnType , class... FunctionArgs>

void Utilities::MutableBind< ReturnType, FunctionArgs >::parse_arguments	(	const std::string &	value_string,
		const Patterns::PatternBase &	pattern = *Patterns::Tools::Convert< TupleType >::to_pattern() )

Parse the arguments to use in function from a string, for next time operator()() is called.

The conversion is performed using a user supplied Patterns::PatternBase object. By default, Patterns::Tools::Convert<TupleType>::to_pattern() is used to determine how to convert from value_string to a TupleType object.

Parameters

value_string	The string to convert from
pattern	A unique pointer to the pattern to use when performing the conversion

Member Data Documentation

function

template<typename ReturnType , class... FunctionArgs>

const std::function<ReturnType(FunctionArgs...)> Utilities::MutableBind< ReturnType, FunctionArgs >::function

private

An std::function that stores the original function.

Definition at line 154 of file mutable_bind.h.

arguments

template<typename ReturnType , class... FunctionArgs>

TupleType Utilities::MutableBind< ReturnType, FunctionArgs >::arguments

private

Currently stored arguments. These are forwarded to the function object above, when calling operator()().

Definition at line 160 of file mutable_bind.h.

---

The documentation for this class was generated from the following file:

• include/deal.II/base/mutable_bind.h