Re: Call unknown function by pointer

On 27 May, 21:23, Roman Perepelitsa <Roman.Perepeli...@gmail.com>
wrote:


In case someone finds it interesting and for future reference,
I'm posting a revised version. I removed the repetition by
using boost::function_types and simplified the code a little
bit.

#include <iostream>
#include <cstdlib>
#include <string>
#include <deque>
#include <boost/variant.hpp>
#include <boost/mpl/copy.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/back_inserter.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/fusion/mpl/begin.hpp>
#include <boost/fusion/mpl/end.hpp>
#include <boost/fusion/include/vector.hpp>
#include <boost/fusion/include/push_back.hpp>
#include <boost/fusion/include/make_fused.hpp>
#include <boost/function_types/function_type.hpp>

typedef boost::variant<int, std::string> Arg;
typedef std::deque<Arg> Args;

// Current implementation support function with
// 0 - 6 arguments.
// If you need more, change this constant.
static const size_t kMaxArguments = 6;

// List of supported argument types can be extended.
// Just add more stuff here.
typedef boost::variant<int, std::string> Arg;
typedef std::deque<Arg> Args;

// Given a return type and an mpl sequence of
// argument types, constructs a function type.
//
// Example:
// make_function<
// int,
// boost::mpl::vector<char, void*>
// >::type == int(char, void*)
template <class R, class A>
struct make_function :
    boost::function_types::function_type<
      typename boost::mpl::copy<
        A, boost::mpl::back_inserter<boost::mpl::vector<R> >
      >::type
    > {};

template <class A>
void CallImpl(void* f, const A& first, Args& second);

template <size_t N, class A>
struct Caller : boost::static_visitor<void> {
   Caller(void* f, const A& first, Args& second)
       : f_(f), first_(first), second_(second) {}

   template <class T>
   void operator()(const T& arg) const {
     CallImpl(f_,
              boost::fusion::push_back(first_, arg),
              second_);
   }

  private:
   void* f_;
   A first_;
   Args& second_;
};

template <class A>
struct Caller<kMaxArguments, A>
     : boost::static_visitor<void> {
   Caller(void*, const A&, Args&) {}
   template <class T>
   void operator()(const T&) const {
     std::cerr << "Too many arguments." << std::endl;
     abort();
   }
};

template <class A>
void CallImpl(void* f, const A& first, Args& second) {
   if (second.empty()) {
     typedef typename make_function<void, A>::type F;
     boost::fusion::make_fused(reinterpret_cast<F*>(f))(first);
   } else {
     Arg front(second.front());
     second.pop_front();
     boost::apply_visitor(
         Caller<boost::mpl::size<A>::value, A>(
             f, first, second), front);
   }
}

void Call(void* f, Args args) {
   CallImpl(f, boost::fusion::vector<>(), args);
}

void F1() {
   std::cout << "F1()" << std::endl;
}

void F2(int a) {
   std::cout << "F2(" << a << ")" << std::endl;
}

void F3(int a, std::string b) {
   std::cout << "F3(" << a << ", " << b << ")" << std::endl;
}

int main() {
   Arg args[] = { 42, "hello" };
   // F1()
   Call(reinterpret_cast<void*>(F1), Args());
   // F2(42)
   Call(reinterpret_cast<void*>(F2), Args(args, args + 1));
   // F3(42, "hello")
   Call(reinterpret_cast<void*>(F3), Args(args, args + 2));
}

Roman Perepelitsa.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]