// Daniel Walker
// May 14, 2008

#include <cassert>
#include <typeinfo>

#include <boost/function.hpp>
#include <boost/function_types/components.hpp>
#include <boost/function_types/function_type.hpp>
#include <boost/function_types/result_type.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/placeholders.hpp>
#include <boost/mpl/pop_front.hpp>
#include <boost/mpl/push_front.hpp>
#include <boost/utility/result_of.hpp>

using namespace boost;

// A wrapper for a "polymorphic" signature, which has no fixed return
// type but instead uses the return type position of builtin call
// signatures to specify the type of a potentially polymorphic
// callable object. For example, boost::function takes plain old call
// signatures like int(int) - the actual signature of a resolved
// function at the call site - but boost:result_of takes "polymorphic"
// signatures of the form functor(int).
template<class Signature>
struct signature
  : mpl::identity<Signature> {
};

// A metafunction to generate an actual builtin, monomorphic call
// signature. By default, assume Signature is in fact already a call
// signature, then specialize for the wrapper above.
template<class CallSignature>
struct call_signature
    : mpl::identity<CallSignature> {
};

template<class Signature>
struct call_signature<signature<Signature> >
    : function_types::function_type<
          mpl::push_front<
              mpl::pop_front<
                  function_types::components<Signature>
              >
            , typename result_of<Signature>::type
          >
      > {
};

// A metafunction to extract the callable object from a polymorphic
// signature. By default, assume Signature is a result_of-style
// signature, then specialize for the wrapper above.
template<class Signature>
struct callable_object
    : function_types::result_type<Signature> {
};

template<class Signature>
struct callable_object<signature<Signature> >
    : function_types::result_type<Signature> {
};

// Cast between two boost::functions with different call signatures
// wrapping the same polymorphic function object.
template<class Signature, class CallSignature>
function<typename call_signature<signature<Signature> >::type>
functional_cast(function<CallSignature> f)
{
    typedef typename callable_object<Signature>::type functor_type;
    functor_type const* p = f.template target<functor_type>();
    if(!p) throw std::bad_cast();
    return function<typename call_signature<signature<Signature> >::type>(*p);
}


// A polymorphic call-wrapper.
template<class Signature> struct polymorphic_function;

// When given a call signature polymorphic_function acts like
// boost::function and can promote second-class functions.
template<class T0, class T1>
struct polymorphic_function<T0(T1)> {
    typedef function<T0(T1)> function_type;
public:
    // Constructors for both first and second class functions
    polymorphic_function() {}
    template<class G> polymorphic_function(G g) : f(g) {}
    polymorphic_function(T0 (*g)(T1)) : f(g) {}

    typedef T0 result_type;
    T0 operator()(T1 t) { return f(t); }
private:
    function_type f;
};

// When given a result_of-style signature where the callable object is
// polymorphic, polymorphic_function is also polymorphic but can no
// longer promote builtins. Use MPL placeholders in the signature to
// specify which function arguments correspond to template parameters.
template<class F>
struct polymorphic_function<F(mpl::placeholders::_1)> {
    typedef F function_type;
public:
    // Constructor for only first-class functions, since polymorphic
    // second-class functions can not be promoted.
    polymorphic_function() {}
    template<class G> polymorphic_function(G g) : f(g) {}

    template<class> struct result;
    template<class T>
    struct result<polymorphic_function(T)>
        : result_of<function_type(T)> {
    };

    template<class T>
    typename result_of<function_type(T)>::type
    operator()(T t) { return f(t); }
private:
    function_type f;
};

// A function.
int f(int i) { return i; }

// A polymorphic functor.
struct g {
    template <class> struct result;
    template <class T>
    struct result<g(T)> {
        typedef T type;
    };
    template<class T>
    T operator()(T t) { return t; }
};

int main()
{
    // Cast between functions with different call signatures.
    {
        function<int(int)> f0 = g();
        function<float(float)> f1 = functional_cast<g(float)>(f0);

        assert(f0(1)/2 == 0);
        assert(f1(1)/2 == .5);
    }

    // Polymorphic function behaves like boost::function when
    // instantiated with a call signature and is polymorphic with a
    // "polymorphic" signature.
    {
        using mpl::placeholders::_1;

        polymorphic_function<int(int)> f0 = f;
        polymorphic_function<int(int)> f1 = g();
        polymorphic_function<g(_1)> f2 = g();

        assert(f0(1)/2 == 0);
        assert(f1(1)/2 == 0);
        assert(f1(1.0)/2 == 0);
        assert(f2(1)/2 == 0);
        assert(f2(1.0)/2 == .5);
    }
}