编程语言
首页 > 编程语言> > Boost.python自动转换参数

Boost.python自动转换参数

作者:互联网

我正在使用boost.python来包装一个将字符串作为构造函数的C类’A’.然后,我有一个函数“ fun(A& arg)”,该函数将对“ A”的引用作为参数.我想为“ fun”使用一个python包装器,这样,如果我传递一个对python字符串的引用的变量,则该引用首先会自动转换为对“ A”的引用.

一个例子可能会有所帮助.在python方面,我希望能够做到这一点:

a = 'some string'
fun(a)

然后让“ a”实际上是(引用)“ A”,而不是(引用)原始字符串.我想这样做是因为我希望能够避免这样写

a = A('some string')
fun(a)

(您可能有充分的理由怀疑这是否是相关的保护程序,但让我们假设这对我来说很重要).

这样有可能吗?如果不使用boost.python,也许直接使用Python-C API?

注意:我知道以下事实:

fun('some string')

无法将对字符串的引用转换为对某种其他类型的引用.

解决方法:

这是可能的,但是解决方案可能取决于Python实现.

例如,在Python 2.7中,可以使用inspect模块和sys.settrace()在特定框架上修改locals().这也可以在Python / C API中完成,但是在Python中处理Python框架通常更容易管理.

在下面的example.py中,update_locals()函数将在给定帧中更新locals():

import inspect
import sys


def _force_locals(old_frame, new_locals):
    ''' Force a new set of locals on a given frame. 

    :param old_frame: The frame to which locals will be applied.
    :type old_frame: frame.
    :param new_locals: What locals() should return for old_frame.
    :type new_locals: dict.

    .. note:: This function will force a custom trace function onto
              the old_frame.  Within the context of a trace function
              (often used for debugging), a frame's f_locals is
              modifiable.  In most execution paths, f_locals is 
              writable but not modifiable.

    '''
    # Force tracing by setting the global tracing function to
    # any non-None function.  
    if not sys.gettrace():
        sys.settrace(lambda *args, **keys: None)

    # Custom trace function that will force locals.
    def trace(frame, event, arg):
        # Update the frame's locals.
        frame.f_locals.update(new_locals)
        # Set frame to use default trace, preventing this trace
        # function from resetting the locals on each trace call.
        del frame.f_trace

    # Set the old frame's trace function to the custom trace.
    old_frame.f_trace = trace


def update_locals(frame, *refs):
    ''' Modifies a frame's locals based on the provided references.

    :param frame: The frame from which a locals will be updated.
    :type frame: frame.
    :param refs: Iterable pair of (old_ref, new_ref) tuples.
    :type refs: Iterable type of pairs.

    '''
    new_locals = frame.f_locals.copy()
    has_changes = False

    # If a frame's local has an identity patch with a provided
    # reference, then update new_locals with the new reference.
    for key, ref in new_locals.iteritems():
        for old_ref, new_ref in refs:
            if ref is old_ref:
                new_locals[key] = new_ref
                has_changes = True

    # If new_locals has changes, then force them onto the frame.
    if has_changes:
        _force_locals(frame, new_locals)

互动用法:

>>> import example
>>> import inspect
>>> x = 42
>>> x
42
>>> example.update_locals(inspect.currentframe(), (x, '3.14'))
>>> x
'3.14'

x变量引用了int(42)对象,但是example.update_locals()函数将x更改为引用了str(‘3.14’)对象.

能够修改调用者的框架后,下一步是在Python中对C fun()进行猴子修补,如果自变量是str的实例,则构造A的实例,然后委派给C fun(A&)函数,并更新呼叫者的框架.

在以下示例中,C垃圾邮件类型和fun(Spam&)函数公开给_example Python模块.

#include <iostream>
#include <string>
#include <boost/python.hpp>

/// @brief Mockup type.
class Spam
{
public:
  explicit Spam(std::string str)
    : str_(str)
  {}

  void action()
  {
    std::cout << "Spam::action(): " << str_ << std::endl;
  }

private:
  std::string str_;
};

/// @brief Mockup function.
void fun(Spam& spam)
{
  std::cout << "fun() -> ";
  spam.action();
}

BOOST_PYTHON_MODULE(_example)
{
  namespace python = boost::python;

  python::class_<Spam>("Spam", python::init<std::string>());
  python::def("fun", &fun);
}

如果提供给fun()的参数是str的实例,则更高级别的示例模块将使用猴子_example.fun()构造Spam对象,并以与上述示例类似的方式操纵调用者的框架:

from _example import *

import inspect
import sys


def _force_locals(old_frame, new_locals):
    ''' Force a new set of locals on a given frame. 

    :param old_frame: The frame to which locals will be applied.
    :type old_frame: frame.
    :param new_locals: What locals() should return for old_frame.
    :type new_locals: dict.

    .. note:: This function will force a custom trace function onto
              the old_frame.  Within the context of a trace function
              (often used for debugging), a frame's f_locals is
              modifiable.  In most execution paths, f_locals is 
              writable but not modifiable.

    '''
    # Force tracing by setting the global tracing function to
    # any non-None function.  
    if not sys.gettrace():
        sys.settrace(lambda *args, **keys: None)

    # Custom trace function that will force locals.
    def trace(frame, event, arg):
        # Update the frame's locals.
        frame.f_locals.update(new_locals)
        # Set frame to use default trace, preventing this trace
        # function from resetting the locals on each trace call.
        del frame.f_trace

    # Set the old frame's trace function to the custom trace.
    old_frame.f_trace = trace


def _update_locals(frame, *refs):
    ''' Modifies a frame's locals based on the provided references.

    :param frame: The frame from which a locals will be updated.
    :type frame: frame.
    :param refs: Iterable pair of (old_ref, new_ref) tuples.
    :type refs: Iterable type of pairs.

    '''
    new_locals = frame.f_locals.copy()
    has_changes = False

    # If a frame's local has an identity patch with a provided
    # reference, then update new_locals with the new reference.
    for key, ref in new_locals.iteritems():
        for old_ref, new_ref in refs:
            if ref is old_ref:
                new_locals[key] = new_ref
                has_changes = True

    # If new_locals has changes, then force them onto the frame.
    if has_changes:
        _force_locals(frame, new_locals)


def _patch_fun():
    old_fun = fun
    # Create a function that will perform custom operations then
    # delegate to the original function.
    def patch(spam, *args, **kwargs):
        if isinstance(spam, str):
            old_spam, spam = spam, Spam(spam)

            # In the caller's frame, force the variables that reference
            # old_spam to now reference spam.
            _update_locals(
                inspect.currentframe(1), # Caller's frame.
                (old_spam, spam))

        return old_fun(spam, *args, **kwargs)
    return patch

fun = _patch_fun()

互动用法:

>>> import example
>>> s1 = example.Spam('abc')
>>> type(s1)
<class '_example.Spam'>
>>> example.fun(s1)
fun() -> Spam::action(): abc
>>> type(s1) # s1's type has not changed.
<class '_example.Spam'>
>>> s2 = 'def'
>>> type(s2)
<type 'str'>
>>> example.fun(s2)
fun() -> Spam::action(): def
>>> type(s2) # s2's type has changed.
<class '_example.Spam'>
>>> example.fun('ghi')
fun() -> Spam::action(): ghi

请注意,以上示例中的帧操作仅修改fun()的调用者的帧,而不修改整个堆栈.

标签:boost-python,boost,reference,python,c-4
来源: https://codeday.me/bug/20191122/2057058.html