Как написать автозаполнение списка параметров метода члена класса в аргументы Variadic? - PullRequest
Новая
       46

Как написать автозаполнение списка параметров метода члена класса в аргументы Variadic?

0 голосов
/ 15 октября 2018

Недавно я написал расширение для Python 3 на C ++, но я столкнулся с некоторыми проблемами, когда вызвал C ++ на python.

Я не знаю, как инкапсулировать приведенный ниже код без необходимости писать обратный вызовфункция повторяется каждый раз?

Я рассматриваю привязку функции обратного вызова и списка параметров в некоторой форме, но я не знаю, как это сделать.

Вот мой основной код: 

class TestClass
{
    PyObject_HEAD
public:

    int add(int a, int b) {
        return (a + b);
    }

};

// ... Ignore some details here ...

static PyObject* function1(TestClass *self, PyObject* args) {

    // How to changed the following code to take the value from PyArg_ParseTuple
    // through the binding function and parameter list?
    int a, b;
    if (!PyArg_ParseTuple(args, "ii", &a, &b))
    {
        return nullptr;
    }

    // How to changed the following code to the return type of the binding function?
    return Py_BuildValue("i", self->add(a, b));
}

Можно ли каким-то образом осуществить вызов типа BINDING_FUNCTION(TestClass::add);?

1 Ответ

0 голосов
/ 15 октября 2018

Да, это возможно, но это занимает нетривиальное количество кода.Я думаю, что слишком много, чтобы легко вписаться в ответ здесь.

Хорошая новость заключается в том, что другие уже написали необходимый вам код и поместили его в библиотеки.Я знаю, что pybind11 (современный) и boost.python (несколько более старый)

Вы можете посмотреть, как эти библиотеки делают это, или использовать эти библиотеки.

Приблизительные необходимые шаги, если вы действительно хотите сделать это самостоятельно:

  • Создание универсальных функций для создания строк формата из типов аргументов функции и типа возврата
  • Создание мета-функции шаблона для определения типа кортежа для хранения аргументов заданной (member-) функции
  • Реализация универсальной функции, которая может заполнить такой кортеж с помощью PyArg_ParseTuple().Это будет использовать функцию генерации строки формата, а определение кортежа
  • реализует обобщенную функцию, которая принимает объект, указатель на функцию (member-) и кортеж с аргументами и которая вызывает функцию-член сприведенные аргументы.У SO есть ответы о том, как это сделать.

Как правило, вы хотите специализировать эту последнюю функцию для функций типа void с возвращаемым типом, и вы можете написать дополнительный код, еслиВы хотите поддерживать бесплатные функции в дополнение к функциям-членам.

Приведенный ниже код предназначен только для образовательных целей , потому что это очень упрощенная реализация описанных выше шагов.Библиотеки, упомянутые ранее, реализуют множество угловых случаев, которые не рассматриваются в этом коде. 

#include <iostream>
#include <sstream>
#include <type_traits>
#include <tuple>

// some object we want to wrap
struct Duck
{
    int MemberFunc( int x, int y, float w)
    {
        std::cout << "Member function called\n";
        return x+ w * y;
    }
};


// PART 1: create format strings for function argument- and return types

// "excercise for the reader": implement these overloads for all supported types
template<typename T> struct Tag{};
const char *GetTypeFormat( const Tag<int>&)
{
    return "i";
}
const char *GetTypeFormat( const Tag<float>&)
{
    return "f";
}

// create a format string from a list of argument types
template< typename... Args>
void GetTypeFormats( std::ostream &strm)
{
    (void)(int[]){0, ((strm << GetTypeFormat(Tag<Args>{})),0)...};
}

// this is quite inefficient because it creates the format string at 
// run-time. Doing this as constexpr is an interesting challenge
// ("...for the reader")
template< typename R, typename Class, typename... Args>
std::string GetArgumentFormats( R (Class::*f)(Args...))
{
     std::stringstream strm;
     GetTypeFormats<Args...>( strm);
     return strm.str();
}

template< typename R, typename Class, typename... Args>
std::string GetReturnFormat( R (Class::*f)(Args...))
{
     std::stringstream strm;
     GetTypeFormats<R>( strm);
     return strm.str();
}

// PART 2: declare std::tuple-type to hold function arguments

// given a list of types that could be function parameter types, define a 
// tuple type that can hold all argument values to such a function
// THIS IS VERY MUCH A SIMPLIFIED IMPLEMENTATION
// This doesn't take pointer types into account for instance.
template< typename F>
struct ArgumentTuple {};

template< typename R, typename Class, typename... Args>
struct ArgumentTuple<R (Class::*)( Args...)>
{
    using type = std::tuple<
        typename std::remove_cv<
            typename std::remove_reference<Args>::type>::type...>;
};


// for demo purposes. emulate python binding functions
using PyObject = void;
bool PyArg_ParseTuple( PyObject *, const char *, ...) {}
template< typename T>
PyObject *Py_BuildValue( const char*, T ){}

// PART 3: given some function pointer, obtain arguments from a PyObject
template<typename F, size_t... Indexes>
auto FillTuple( PyObject *obj, F f, std::index_sequence<Indexes...>) -> typename ArgumentTuple<F>::type
{
    using std::get;
    typename ArgumentTuple<F>::type arguments;
    // no error checking whatsoever: "exercise for the reader" 

    PyArg_ParseTuple( obj, GetArgumentFormats( f).c_str(), &get<Indexes>( arguments)...);
    return arguments;
}

template< typename R, typename Class, typename... Args>
auto FillTuple( PyObject *obj, R (Class::*f)(Args...))
{
    return FillTuple( obj, f, std::index_sequence_for<Args...>{});
}

// PART 4, call a member function given a tuple of arguments

// helper function
template< 
    typename R, 
    typename Class, 
    typename MF, 
    typename ArgumentTuple, 
    size_t... Indexes>
R Apply( Class &obj, MF f, ArgumentTuple &args, std::index_sequence<Indexes...>)
{
    using std::get;
    return (obj.*f)( get<Indexes>( args)...);
}

// Apply a (member-) function to a tuple of arguments.
template<
    typename R,
    typename Class,
    typename ArgumentTuple,
    typename... Args>
R Apply( Class &obj, R (Class::*f)( Args...), ArgumentTuple &args)
{
    return Apply<R>( obj, f, args, std::index_sequence_for<Args...>{});
}


// LAST PART: glue everything together in a single function. 
#define BIND_MEMBER_FUNCTION( class_, memberfunc_)                  \
    PyObject *Call##class_##memberfunc_( class_ *self, PyObject *args)\
    {                                                               \
        /* no error checking whatsoever: "exercise for the reader"*/\
        auto arguments = FillTuple( args, &class_::memberfunc_);    \
        /* deal with void-returning functions: yet another EFTR */  \
        return Py_BuildValue(                                       \
            GetReturnFormat( &class_::memberfunc_).c_str(),         \
            Apply( *self, &class_::memberfunc_, arguments));        \
    }                                                               \
    /**/

BIND_MEMBER_FUNCTION( Duck, MemberFunc);
...