CLASS TEMPLATE F(3)

NAME
boost::functionN - A set of generalized function pointers that can be used for callbacks or wrapping function objects.

SYNOPSIS

// In header: <boost/function.hpp>
template<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;
  // member classes/structs/unions
  // 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>&);

DESCRIPTION

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.

  functionN public construct/copy/destruct

    1.

    functionN();

    Postconditions:
        this->empty()

    Throws:
        Will not throw.

    2.

    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.

    3.

    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.

    4.

    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.

    5.

    functionN& operator=(const functionN& f);

    Postconditions:
        If copy construction does not throw, *this targets a copy of f's target, if it has one, or is empty if f.empty(). If copy construction does throw, this->empty().

    6.

    ~functionN();

    Effects:
        If !this->empty(), destroys the target of this.

  functionN modifiers

    1.

    void swap(const functionN& f);

    Effects:
        Interchanges the targets of *this and f.

    2.

    void clear();

    Postconditions:
        this->empty()

  functionN capacity

    1.

    bool empty() const;

    Returns:
        false if this has a target, and true otherwise.

    Throws:
        Will not throw.

    2.

    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.

    3.

    bool operator!() const;

    Returns:
        this->empty()

    Throws:
        Will not throw.

  functionN target access

    1.

    template<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.

    2.

    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)

    3.

    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 invocation

    1.

    result_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 specialized algorithms

    1.

    template<typename T1, typename T2, ..., typename TN>
      void swap(functionN<T1, T2, ..., TN>& f1, functionN<T1, T2, ..., TN>& f2);

    Effects:
        f1.swap(f2)

  functionN comparison operators

    1.

    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 stores an object of type Functor and one of the following conditions applies:

            &#8226; g is of type reference_wrapper<Functor> and f.target<Functor>() == g.get_pointer().

            &#8226; g is not of type reference_wrapper<Functor> and function_equal(*(f.target<Functor>()), g).

        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.

        2.

        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:

                &#8226; g is of type reference_wrapper<Functor> and f.target<Functor>() != g.get_pointer().

                &#8226; g is not of type reference_wrapper<Functor> and !function_equal(*(f.target<Functor>()), g).

            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.