[boost] boost::ref for function objects

From: Douglas Gregor (gregod_at_[hidden])
Date: 2003-02-12 17:36:25

We've discussed making boost::ref/boost::cref work for arbitrary functions 
objects before. I just committed a version of ref.hpp that supports this 
ability to the sandbox. With this code, you can write:

  std::transform(c.begin(), c.end(), out, boost::ref(f));

or, if you don't want the return type deduced, specify it as in Boost.Bind:

  std::transform(c.begin(), c.end(), out, boost::ref<float>(f));

Features of this implementation:
  - Return type deduction (discussed below)
  - Argument type deduction  (discussed below)
  - Able to handle function objects that have multiple arities (e.g., can be 
invoked with 0 or 2 arguments)

The implementation is here:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/*checkout*/boost-sandbox/boost-sandbox/boost/ref.hpp?rev=HEAD&content-type=text/plain

Testcases are here:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/*checkout*/boost-sandbox/boost-sandbox/libs/utility/ref_call_test.cpp?rev=HEAD&content-type=text/plain

------Return type deduction------
  - If the user specifies a return type, use it
  - Otherwise, if the class has a result_type typedef, use it
  - Otherwise, use Boost.Lambda-style sig<arg_types>::type

------Argument type deduction------  
  - If typedefs arg1_type, arg2_type, ..., argN_type are available, use 
_precisely_ those argument types (as in Boost.Function) to define 
operator()(arg1_type), operator()(arg1_type, arg2_type), etc, up to 'N' for 
that particular class.

  - Otherwise, if the class has an argument_type typedef, define 
operator()(const argument_type&). If the class also has first_argument_type 
and second_argument_type, define 
  operator()(const first_argument_type&, const second_argument_type&);

  - Otherwise, if the class has first_argument_type and second_argument_type, 
define 
  operator()(const first_argument_type&, const second_argument_type&);

  - Otherwise, define a bunch of function templates that deduce the argument 
types at call time, e.g.,
    template<typename T1, typename T2, ..., typename TN>
    return-type-as-mentioned-before operator()(T1&, T2&, ..., TN&);

There is always an operator() that takes no arguments.

------Compatibility------
This version of ref.hpp is backwards-compatible with the existing version of 
ref.hpp on a compiler that can handle the new ref.hpp (needs partial 
specialization and proper SFINAE handling). At some point I'll write a 
stripped-down version that other compilers can handle. The stripped-down 
version will feel a lot more like boost::bind:
  - Return type deduction will be limited to using a user-supplied return 
type, or else using ::result_type
  - Argument type deduction won't look for argN_types, argument_type, or 
first/second_argument_type, but will fall back to the set of function 
templates that deduce the argument types from the call.

        Doug