Execution

I banged my head against this problem for a little while, until I remembered a trick that I’d used a while back, that involved partial template specialization and a one line superstar called Int2Type.

template<int T> struct Int2Type {};

Hopefully some code will be less confusing than that description!

/**
* The executor is a class with operator() specialized on the class Int2Type<N>, where N is the
* arity of the function we're calling. By specializing on the arity, we know the number of parameters
* the function expects, and can extract these from the vector<boost::any> and cast to the correct type
*/ 
template<class Fn, class ParamTypes>
struct Executor;

// 0 parameters
template<class ParamTypes>
struct Executor<Int2Type<0>, ParamTypes> {
  template<class Fn> void operator()(Fn& fn, const vector<boost::any>& /*params*/) {
    fn();
  }
};

// 1 parameter
template<class ParamTypes>
struct Executor<Int2Type<1>, ParamTypes> {
  template<class Fn> void operator()(Fn& fn, const vector<boost::any>& params) {
    fn( boost::any_cast<at<ParamTypes, int_<0> >::type>(params[0]) );
  }
};

// 2 parameters
template<class ParamTypes>
struct Executor<Int2Type<2>, ParamTypes> {
  template<class Fn> void operator()(Fn& fn, const vector<boost::any>& params) {
    fn( 
      boost::any_cast<at<ParamTypes, int_<0> >::type>(params[0]),
      boost::any_cast<at<ParamTypes, int_<1> >::type>(params[1]) );
  }
};

And once again we update our Execute method slightly to create the proper instance of Executor and call it.

// Typedef for the executor (based on the arity of the function)
typedef Executor< Int2Type<boost::function_types::function_arity<T>::value>, ParamTypes> Executor;

int Execute(lua_State* lua_state) const {
  AnyParams params;
  boost::mpl::for_each<ParamTypes>(Extractor(lua_state, params));
  Executor f;
  f(fn_, params);
  return 0;
}

Handling Return Values

if (function_has_return_value) {
  return_value = function();
  push_on_lua_stack(return_value);
} else {
  function();
}

Finding out if we have a return value or not is solved by combining function_types magic to get the type of the result, and using the is_void metafunction found in boost.type_traits to determine if it’s void.

typedef typename result_type<T>::type ResultType;
enum { IsVoidResult = boost::is_void<ResultType>::value };

// Typedef for the executor (based on the arity of the function)
typedef Executor< Int2Type<function_arity<T>::value>, ParamTypes, ResultType > Executor;

// Executer for void return type
int Execute(lua_State* lua_state, Int2Type<true>) const {
  AnyParams params;
  for_each<ParamTypes>(Extractor(lua_state, params));
  Executor f;
  f(fn_, params);
  return 0;
}

// Executer for non void return type
int Execute(lua_State* lua_state, Int2Type<false>) const {
  AnyParams params;
  for_each<ParamTypes>(Extractor(lua_state, params));
  Executor f;
  AddReturnValue(lua_state, f(fn_, params));
  return 1;
}

static int callback(lua_State* lua_state){
  const CommandT* this_ptr = reinterpret_cast<CommandT*>(lua_tointeger(lua_state, lua_upvalueindex(1)));
  return this_ptr->Execute(lua_state, Int2Type<IsVoidResult>());
}

Once this was solved, pushing the correct value to the Lua stack was a simple matter of overloading AddReturnValue for the types we wanted to be able to return, and a call to the correct lua_pushXXX function.

void AddReturnValue(lua_State* lua_state, const bool value) {
  lua_pushboolean(lua_state, value ? 1 : 0);
}

void AddReturnValue(lua_State* lua_state, const int value) {
  lua_pushinteger(lua_state, value);
}

Future Work

• Named parameters, and a single dispatch function. A friend at work was working on a system where he just exported a single function from C++ called dispatch, and that function took two parameters: the name of an internal function to call, and a table containing pairs of parameter names and values. This would require adding support for tables, amongst other things.
• Support for member functions. Right now, we just handle global functions, but it should be fairly simple to extend to support member function pointers as well. This will require handling objects going out of scope and unregistering their callbacks when they do.
• Multiple return values. Might be more fun than useful, but I’m interested in seeing if I can get Boost.Tuple to interact with this system, and allow for multiple return values on the Lua stack.
• Use the Preprocessor Library for generating the execute code. That code is just repetitive and error prone to write for a greater number of parameters, and seems like a great fit for the Preprocessor Library.
• Understand what’s going on under the hood of FunctionTypes. I think this can be summarized with *gulp*.

Sample Code

References

³ Using boost::any is a bit of overkill, as we know when we extract the parameters that we’re getting the correct types, so we don’t need the extra type safety/overhead that any_cast gives us