Re: [boost] [functional] [overloaded_function] polymorphic functions?

18 Feb 2012


      On Fri, Feb 17, 2012 at 10:16 PM, Lorenzo Caminiti
<lorcaminiti@gmail.com> wrote:
...
Hello all,
I spent some time trying to make overloaded_function support
polymorphic functions but I had little success :(
1) I was able to do this (see code below):
   overloaded_function<
         void (int)
       , functor<poly, void (generic)>
   > o(f, p);
   o(321);
   o(3.21);
   o("cba");
But I don't like it because I explicitly have to pass the functor type
poly. I wanted instead to only use generic to tag the template
parameters in the signature:
   overloaded_function<
         void (int)
       , void (generic)
   > o(f, p);
   o(321);
   o(3.21);
   o("cba");
I'd consider this acceptable but I wasn't able to program this because
I loose p's type (poly) in base so base cannot hold a reference to the
functor p... Is there a way around this? (Some type-erasure magic
maybe??)
Actually, with the small change base<R (Ftor::*)(generic)> I can do this:

    overloaded_function<
          void (int)
        , void (poly::*)(generic)
    > o(f, p);
    o(321);
    o(3.21);
    o("cba");

Which looks better to me than using functor<poly, void (generic)> but
still: Is there any way I can get rid of specifying the functor type
poly completely?
...
2) I don't think this can work with function templates because in
order to get a pointer to a function template you have to instantiate
it:
   g<char*>
Now I can get the function pointer but it's not polymorphic anymore...
3) I don't think there is any way to implement
make_overloaded_function with polymorphic types because I can't
re-construct the function signature from the functor given that its
operator contains template parameters... I have no idea on how to work
around this...
If you have suggestions for 1, 2, or 3), they are welcome. Otherwise,
it seems that supporting polymorphic functions in overloaded_function
is not really feasible...
The little I got so far:
#include <boost/function.hpp>
#include <boost/type_traits/function_traits.hpp>
#include <iostream>
void f(int x) { std::cout << x << std::endl; }
template<typename T>
void g(T x) { std::cout << x << std::endl; }
struct poly {
   template<typename T>
   void operator()(T x) { std::cout << x << std::endl; }
};
template<typename F>
struct base {
   template<typename G>
   base(G g) : f_(g) {}
   typename boost::function_traits<F>::result_type operator()(
       typename boost::function_traits<F>::arg1_type arg1
   ) {
       return f_(arg1);
   }
private:
   boost::function<F> f_;
};
struct generic;
template<typename Ftor, typename F>
struct functor;
template<typename Ftor, typename R>
struct base< functor<Ftor, R (generic)> > {
   base(Ftor& ftor) : ftor_(ftor) {}
   template<typename Arg1>
   R operator()(Arg1 arg1) { return ftor_(arg1); }
private:
   Ftor& ftor_;
};
template<typename F1, typename F2>
struct overloaded_function : base<F1>, base<F2> {
   template<typename G1, typename G2>
   overloaded_function(G1 g1, G2 g2) : base<F1>(g1), base<F2>(g2) {}
   using base<F1>::operator();
   using base<F2>::operator();
};
int main() {
   f(123);
   g("xyz");
   boost::function<void (char*)> gg = g<char*>;
   poly p;
   p(1.23);
   p("abc");
   overloaded_function<
         void (int)
       , functor<poly, void (generic)>
   > o(f, p);
   o(321);
   o(3.21);
   o("cba");
   return 0;
}
--Lorenzo