Here MAX_ARGS is an implementation-defined constant that defines the maximum number of function arguments supported by Boost.Function and will be at least 10. The MAX_ARGS constant referred to in this document need not have any direct representation in the library.
-namespace boost {
- class function_base
+namespace boost {
+ class function_base
{
- bool empty() const;
- operator bool() const;
+ bool empty() const;
+ operator bool() const;
};
// For N in [0, MAX_ARGS]
- template<typename ResultType,
- typename Arg1,
- typename Arg2,
+ template<typename ResultType,
+ typename Arg1,
+ typename Arg2,
...
- typename ArgN,
- typename Policy = empty_function_policy,
- typename Mixin = empty_function_mixin,
- typename Allocator = std::allocator<function_base> >
- class functionN : public function_base, public Mixin
+ typename ArgN,
+ typename Policy = empty_function_policy,
+ typename Mixin = empty_function_mixin,
+ typename Allocator = std::allocator<function_base> >
+ class functionN : public function_base, public Mixin
{
- typedef ResultType result_type;
- typedef Policy policy_type;
- typedef Mixin mixin_type;
- typedef Allocator allocator_type;
+ typedef ResultType result_type;
+ typedef Policy policy_type;
+ typedef Mixin mixin_type;
+ typedef Allocator allocator_type;
- typedef Arg1 argument_type; // If N == 1
+ typedef Arg1 argument_type; // If N == 1
- typedef Arg1 first_argument_type; // If N == 2
- typedef Arg2 second_argument_type; // If N == 2
+ typedef Arg1 first_argument_type; // If N == 2
+ typedef Arg2 second_argument_type; // If N == 2
// Construction
- explicit functionN(const Mixin& = Mixin());
- functionN(const functionN&);
- template<typename F> functionN(const F&, const Mixin& = Mixin());
+ explicit functionN(const Mixin& = Mixin());
+ functionN(const functionN&);
+ template<typename F> functionN(const F&, const Mixin& = Mixin());
// Assignment
- functionN& operator=(const functionN&);
- template<typename F> functionN& operator=(const F&);
- void set(const functionN&);
- template<typename F> void set(const F&);
- void swap(functionN&);
- void clear();
+ functionN& operator=(const functionN&);
+ template<typename F> functionN& operator=(const F&);
+ void set(const functionN&);
+ template<typename F> void set(const F&);
+ void swap(functionN&);
+ void clear();
// Invocation
- result_type operator()(Arg1 a1, Arg2 a2, ..., ArgN aN);
- result_type operator()(Arg1 a1, Arg2 a2, ..., ArgN aN) const;
+ result_type operator()(Arg1 a1, Arg2 a2, ..., ArgN aN);
+ result_type operator()(Arg1 a1, Arg2 a2, ..., ArgN aN) const;
};
- template<typename ResultType,
- typename Arg1,
- typename Arg2,
+ template<typename ResultType,
+ typename Arg1,
+ typename Arg2,
...
- typename ArgN,
- typename Policy,
- typename Mixin,
- typename Allocator>
- inline void swap(const function<Arg1, Arg2, ...ArgN, Policy, Mixin, Allocator>&,
- const function<Arg1, Arg2, ...ArgN, Policy, Mixin, Allocator>&);
+ typename ArgN,
+ typename Policy,
+ typename Mixin,
+ typename Allocator>
+ void swap(const function<Arg1, Arg2, ..., ArgN, Policy, Mixin, Allocator>&,
+ const function<Arg1, Arg2, ..., ArgN, Policy, Mixin, Allocator>&);
// For any N in [0, MAX_ARGS]
- template<typename ResultType,
- typename Arg1,
- typename Arg2,
+ template<typename ResultType,
+ typename Arg1,
+ typename Arg2,
...
- typename ArgN,
- typename ArgN+1 = implementation-defined,
- typename ArgN+2 = implementation-defined,
+ typename ArgN,
+ typename ArgN+1 = implementation-defined,
+ typename ArgN+2 = implementation-defined,
...
- typename ArgMAX_ARGS = implementation-defined>
- class function : public functionN<Arg1, Arg2, ..., ArgN>
+ typename ArgMAX_ARGS = implementation-defined>
+ class function : public functionN<Arg1, Arg2, ..., ArgN>
{
// Construction
function();
- function(const function&);
- functionN(const functionN&);
- template<typename F> functionN(const F&);
+ function(const function&);
+ functionN(const functionN&);
+ template<typename F> functionN(const F&);
// Assignment
- function& operator=(const function&);
- functionN& operator=(const functionN&);
- template<typename F> function& operator=(const F&);
- void set(const function&);
- void set(const functionN&);
- template<typename F> void set(const F&);
+ function& operator=(const function&);
+ functionN& operator=(const functionN&);
+ template<typename F> function& operator=(const F&);
+ void set(const function&);
+ void set(const functionN&);
+ template<typename F> void set(const F&);
};
- template<typename ResultType,
- typename Arg1,
- typename Arg2,
+ template<typename ResultType,
+ typename Arg1,
+ typename Arg2,
...
- typename ArgMAX_ARGS>
- inline void swap(const function<Arg1, Arg2, ...ArgMAX_ARGS>&,
- const function<Arg1, Arg2, ...ArgMAX_ARGS>&);
+ typename ArgMAX_ARGS>
+ void swap(const function<Arg1, Arg2, ..., ArgMAX_ARGS>&,
+ const function<Arg1, Arg2, ..., ArgMAX_ARGS>&);
}
function_base Class function_base is the common base class for all Boost.Function objects. Objects of type function_base may not be created directly.
-
true if the function object has a target, false otherwise.!empty()functionN Class template functionN is actually a family of related classes function0, function1, etc., up to some implementation-defined maximum. In this context, N refers to the number of parameters and f refers to the implicit object parameter.
-
explicit functionN(const Mixin& = Mixin());
+
explicit functionN(const Mixin& = Mixin());
Mixin subobject with the given mixin.f.empty(). functionN(const functionN& g);
+
functionN(const functionN& g);
f contains a copy of the g's target, if it has one, or is empty if g.empty(). The mixin for the f is copy-constructed from the mixin of g. template<typename F> functionN(const F& g, const Mixin& = Mixin());
+
template<typename F> functionN(const F& g, const Mixin& = Mixin());
g is a compatible function object.Mixin subobject from the given mixin.f targets a copy of g if g is nonempty, or f.empty() if g is empty.g is a reference-to-const because it is a portable, efficient, and concise way to accept any function object or function pointer. In the case of a function pointer, the type of g is reference-to-const pointer-to-function.g is a reference-to-const because it is a portable, efficient, and concise way to accept any function object or function pointer. In the case of a function pointer, the type of g is reference-to-const pointer-to-function. functionN& operator=(const functionN& g);
+
functionN& operator=(const functionN& g);
f targets a copy of g's target, if it has one, or is empty if g.empty(). The mixin for f is assigned the value of the mixin for g.*this. template<typename F> functionN& operator=(const F& g);
+
template<typename F> functionN& operator=(const F& g);
g is a compatible function object.f targets a copy of g if g is nonempty, or f.empty() if g is empty.*this.g is a reference-to-const because it is a portable, efficient, and concise way to accept any function object or function pointer. In the case of a function pointer, the type of g is reference-to-const pointer-to-function.g is a reference-to-const because it is a portable, efficient, and concise way to accept any function object or function pointer. In the case of a function pointer, the type of g is reference-to-const pointer-to-function. void set(const functionN& g);
+
*this = g. template<typename F> void set(const F& g);
+
template<typename F> void set(const F& g);
*this = g.f and g and swaps the mixins of f and g. result_type operator()(Arg1 a1, Arg2 a2, ..., ArgN aN);
+
result_type operator()(Arg1 a1, Arg2 a2, ..., ArgN aN);
!empty().const or volatile qualified.
+ const or volatile qualified.
policy_type policy;policy.precall(this); result_type operator()(Arg1 a1, Arg2 a2, ..., ArgN aN) const;
+
result_type operator()(Arg1 a1, Arg2 a2, ..., ArgN aN) const;
!empty().const qualified but not volatile qualified.
+ const qualified but not volatile qualified.
policy_type policy;policy.precall(this);
-template<typename ResultType,
- typename Arg1,
- typename Arg2,
+template<typename ResultType,
+ typename Arg1,
+ typename Arg2,
...
- typename ArgN,
- typename Policy,
- typename Mixin,
- typename Allocator>
-inline void swap(const functionN<Arg1, Arg2, ...ArgN, Policy, Mixin, Allocator>& f,
- const functionN<Arg1, Arg2, ...ArgN, Policy, Mixin, Allocator>& g);
+ typename ArgN,
+ typename Policy,
+ typename Mixin,
+ typename Allocator>
+void swap(const functionN<Arg1, Arg2, ..., ArgN, Policy, Mixin, Allocator>& f,
+ const functionN<Arg1, Arg2, ..., ArgN, Policy, Mixin, Allocator>& g);
-template<typename ResultType,
- typename Arg1,
- typename Arg2,
+template<typename ResultType,
+ typename Arg1,
+ typename Arg2,
...
- typename ArgMAX_ARGS>
-inline void swap(const function<Arg1, Arg2, ...ArgMAX_ARGS>& f,
- const function<Arg1, Arg2, ...ArgMAX_ARGS>& g);
+ typename ArgMAX_ARGS>
+void swap(const function<Arg1, Arg2, ..., ArgMAX_ARGS>& f,
+ const function<Arg1, Arg2, ..., ArgMAX_ARGS>& g);
f.swap(g);