Class template functionNboost::functionN — A set of generalized function pointers that can be used for callbacks or wrapping function objects. Synopsistemplate<typename R, typename T1, typename T2, ..., typename TN> class functionN : public function_base { public: // types typedef R result_type; typedef T1 argument_type; // If N == 1 typedef T1 first_argument_type; // If N == 2 typedef T2 second_argument_type; // If N == 2 typedef T1 arg1_type; typedef T2 arg2_type; . . . typedef TN argN_type; // static constants static const int arity = N; // Lambda library support template<typename Args> struct sig { // types typedef result_type type; }; // construct/copy/destruct functionN(); functionN(const functionN&); template<typename F> functionN(F); template<typename F, typename Allocator> functionN(F, Allocator); functionN& operator=(const functionN&); ~functionN(); // modifiers void swap(const functionN&); void clear(); // capacity bool empty() const; operator safe_bool() const; bool operator!() const; // target access template<typename Functor> Functor* target(); template<typename Functor> const Functor* target() const; template<typename Functor> bool contains(const Functor&) const; const std::type_info& target_type() const; // invocation result_type operator()(arg1_type, arg2_type, ..., argN_type) const; }; // specialized algorithms template<typename T1, typename T2, ..., typename TN> void swap(functionN<T1, T2, ..., TN>&, functionN<T1, T2, ..., TN>&); // comparison operators template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator==(const functionN<T1, T2, ..., TN>&, Functor); template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator==(Functor, const functionN<T1, T2, ..., TN>&); template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator==(const functionN<T1, T2, ..., TN>&, reference_wrapper<Functor>); template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator==(reference_wrapper<Functor>, const functionN<T1, T2, ..., TN>&); template<typename T1, typename T2, ..., typename TN, typename U1, typename U2, ..., typename UN> void operator==(const functionN<T1, T2, ..., TN>&, const functionN<U1, U2, ..., UN>&); template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator!=(const functionN<T1, T2, ..., TN>&, Functor); template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator!=(Functor, const functionN<T1, T2, ..., TN>&); template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator!=(const functionN<T1, T2, ..., TN>&, reference_wrapper<Functor>); template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator!=(reference_wrapper<Functor>, const functionN<T1, T2, ..., TN>&); template<typename T1, typename T2, ..., typename TN, typename U1, typename U2, ..., typename UN> void operator!=(const functionN<T1, T2, ..., TN>&, const functionN<U1, U2, ..., UN>&); DescriptionClass template functionN is
actually a family of related classes function0, function1, etc., up to some
implementation-defined maximum. In this context,
|
Postconditions: |
this->empty() |
Throws: |
Will not throw. |
functionN(const functionN& f);
Postconditions: |
Contains a copy of the f 's target, if it has one, or is empty if f.empty() . |
Throws: |
Will not throw unless copying the target of f throws. |
template<typename F> functionN(F f);
Requires: |
F is a function object Callable from this . |
Postconditions: |
*this targets a copy of f if f is nonempty, or this->empty() if f is empty. |
template<typename F, typename Allocator> functionN(F f, Allocator alloc);
Requires: |
F is a function object Callable from this , Allocator is an allocator. The copy constructor and destructor of Allocator shall not throw. |
Postconditions: |
*this targets a copy of f if f is nonempty, or this->empty() if f is empty. |
Effects: |
If memory allocation is required, the given allocator (or a copy of it) will be used to allocate that memory. |
functionN& operator=(const functionN& f);
~functionN();
Effects: |
If !this->empty() , destroys the target of this. |
functionN
capacitybool empty() const;
Returns: |
false if this has a target, and true otherwise. |
Throws: |
Will not throw. |
operator safe_bool() const;
Returns: |
A safe_bool that evaluates false in a boolean context when this->empty() , and true otherwise. |
Throws: |
Will not throw. |
bool operator!() const;
Returns: |
this->empty() |
Throws: |
Will not throw. |
functionN
target accesstemplate<typename Functor> Functor* target(); template<typename Functor> const Functor* target() const;
Returns: |
If this stores a target of type
Functor , returns the address of the
target. Otherwise, returns the NULL
pointer. |
Throws: |
Will not throw. |
template<typename Functor> bool contains(const Functor& f) const;
Returns: |
true if this->target<Functor>() is non-NULL and function_equal(*(this->target<Functor>()), f)
|
const std::type_info& target_type() const;
Returns: |
typeid of the target function object, or typeid(void) if this->empty() . |
Throws: |
Will not throw. |
functionN
invocationresult_type operator()(arg1_type a1, arg2_type a2, ..., argN_type aN) const;
Effects: |
f(a1, a2, ..., aN) , where f is the target of *this . |
Returns: |
if R is void , nothing is returned; otherwise, the return value of the call to f is returned. |
Throws: |
bad_function_call if this->empty() . Otherwise, may through any exception thrown by the target function f . |
functionN
comparison operatorstemplate<typename T1, typename T2, ..., typename TN, typename Functor> bool operator==(const functionN<T1, T2, ..., TN>& f, Functor g); template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator==(Functor g, const functionN<T1, T2, ..., TN>& f); template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator==(const functionN<T1, T2, ..., TN>& f, reference_wrapper<Functor> g); template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator==(reference_wrapper<Functor> g, const functionN<T1, T2, ..., TN>& f); template<typename T1, typename T2, ..., typename TN, typename U1, typename U2, ..., typename UN> void operator==(const functionN<T1, T2, ..., TN>& f1, const functionN<U1, U2, ..., UN>& f2);
Returns: |
True when f stores an object of
type Functor and one of the following conditions applies:
|
Notes: |
functionN
objects are not
EqualityComparable. |
Rationale: |
The safe_bool conversion
opens a loophole whereby two functionN
instances can be compared via == , although this
is not feasible to implement. The undefined void
operator== closes the loophole and ensures a
compile-time or link-time error. |
template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator!=(const functionN<T1, T2, ..., TN>& f, Functor g); template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator!=(Functor g, const functionN<T1, T2, ..., TN>& f); template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator!=(const functionN<T1, T2, ..., TN>& f, reference_wrapper<Functor> g); template<typename T1, typename T2, ..., typename TN, typename Functor> bool operator!=(reference_wrapper<Functor> g, const functionN<T1, T2, ..., TN>& f); template<typename T1, typename T2, ..., typename TN, typename U1, typename U2, ..., typename UN> void operator!=(const functionN<T1, T2, ..., TN>& f1, const functionN<U1, U2, ..., UN>& f2);
Returns: |
True when f does not store an
object of type Functor or it stores an object of
type Functor and one of the following conditions
applies:
|
Notes: |
functionN
objects are not
EqualityComparable. |
Rationale: |
The safe_bool conversion
opens a loophole whereby two functionN
instances can be compared via != , although this
is not feasible to implement. The undefined void
operator!= closes the loophole and ensures a
compile-time or link-time error. |