Exporting wrapped functions doesn't work

I find myself in need of exporting a whole lot of functions to Python which require a wrapper (the API needs locking and whatnot).

The following code probably should work (pybind11 can handle it, for the most part), but doesn't.

```
#include
#include

template
struct wrap
{
using funct_type = R(*)(Args...);
funct_type func;
wrap(funct_type f): func(f) {};
R operator()(Args&&... args)
{
std::cout << "before calling\n";
R ret=func(std::forward(args)...);
std::cout << "After calling\n";
return ret;
}
};

class bar {};
class foo : bar {
public:
enum xfoo { FOO=1, BAR=2, BAZ=3 };
static int add(int a, int b, enum xfoo c) { return a+b; }
static int add2(int a, int b) { return a+b; }
};

BOOST_PYTHON_MODULE(example)
{
using namespace boost::python;

// this works
std::cout << "Result" << wrap{foo::add}(1,2, foo::xfoo::FOO) << std::endl;

// so does this
def("add", foo::add, "A function that adds two numbers and no enum");

// this works with pybind11 but not boost
def("add2", wrap{foo::add2}, "A function that adds two numbers");

// this works with neither
def("add", wrap{foo::add}, "A function that adds two numbers and no enum");
}
```

Start by reproducing the wrapped-function examples in the issue, then inspect the boost::python::def entry point and its handling of callable objects. Done means the wrapped add2 and add examples can be exported successfully, matching the cases that already work directly.

Escrita pelo modelo de indexação a partir do texto da issue.