23

状況

SWIG を使用して C++ API の Python 言語バインディングを作成したいと考えています。一部の API 関数は例外をスローする場合があります。C++ アプリケーションには、次の例のように、自己定義の例外の階層があります。

std::exception
  -> API::Exception
    -> API::NetworkException
      -> API::TimeoutException
      -> API::UnreachableException
    -> API::InvalidAddressException

望ましい動作は次のとおりです。

  1. すべての例外タイプは、一致する Python クラスをwrapperとして持つ必要があります。これらのラッパー クラスは、有効な Python 例外である必要があります。

  2. API 呼び出しがC++ 例外をスローした場合、それをキャッチする必要があります。対応する Python 例外(つまり、キャッチされた C++ 例外のラッパー クラス) をスローする必要があります。

  3. これは動的なプロセスである必要があります。Python の例外タイプは実行時に決定され、キャッチされた C++ 例外の実行時のタイプのみに基づいて決定されます。この方法では、SWIG インターフェイス ファイルに完全な例外階層を記述する必要はありません。

問題と質問

  1. ラッパー クラスは Python の例外ではありません。

    SWIG はすべての自己定義の例外 (他のクラスと同様) に対してラッパー クラスを作成しますが、これらのクラスは Python の例外ではありません。API::Exception基本例外 (例)のラッパーは、Python のすべての例外が派生する必要がある Python クラスのObject代わりに拡張されます。BaseException

    さらに、SWIG に手動で親クラスを追加させることはできないようです。これは、Java で SWIG を使用する場合に可能であることに注意して%typemap(javabase)ください (詳細については、 SWIG のドキュメントを参照してください)。

  2. Python C APIはどのようにしてユーザー定義の例外をスローできますか?

    Python C API から Python 例外をスローする最も一般的な方法は、PyErr_SetString [reference]を呼び出すことです。これは、以下のデモ アプリケーションにも示されています。

    しかし、これは Python の標準 (組み込み) 例外の場合は些細なことです。なぜなら、それらへの参照は Python C API のグローバル変数 [参照] に格納されるからです。

    自己定義の例外への参照を取得するPyErr_NewException [参照]メソッドがあることは知っていますが、これは機能しませんでした。

  3. Python C APIはどのようにして実行時に C++ 型を評価し、対応する Python ラッパー クラスを名前で見つけることができますか?

    Python C APIのリフレクション部分を介して、実行時に Python クラスを名前で検索できると想定しています。これは行く方法ですか？そして、それは実際にどのように行われますか？

デモ申し込み

この問題を試すために、数値の階乗を計算する関数を 1 つ持つ小さな C++ API を作成しました。これには、1 つのクラスのみで構成される、最小限の自己定義の例外階層がありますTooBigException。

この例外は一般的な問題の基本例外として機能し、アプリケーションはそのサブクラスで動作する必要があることに注意してください。これは、ソリューションが、キャッチされた例外の動的 (つまりランタイム) タイプのみを使用して、Python で例外を再スローできることを意味します (以下を参照)。

デモ アプリケーションの完全なソース コードは次のとおりです。

// File: numbers.h
namespace numbers {
int fact(int n);
}

// File: numbers.cpp
#include "TooBigException.h"
namespace numbers {
int fact(int n) {
    if (n > 10) throw TooBigException("Value too big", n);
    else if (n <= 1) return 1;
    else return n*fact(n-1);
}
}

// File: TooBigException.h
namespace numbers {
class TooBigException: public std::exception {
public:
    explicit TooBigException(const std::string & inMessage,
                             const int inValue);
    virtual ~TooBigException() throw() {}
    virtual const char* what() const throw();
    const std::string & message() const;
    const int value() const;
private:
    std::string mMessage;
    int mValue;
};
}

// File: TooBigException.cpp
#include "TooBigException.h"
namespace numbers {
TooBigException::TooBigException(const std::string & inMessage, const int inValue):
    std::exception(),
    mMessage(inMessage),
    mValue(inValue)
{
}
const char* TooBigException::what() const throw(){
    return mMessage.c_str();
}
const std::string & TooBigException::message() const {
    return mMessage;
}
const int TooBigException::value() const {
    return mValue;
}
}

Python バインディングを取得するには、次の SWIG インターフェイス ファイルを使用します。

// File: numbers.i
%module numbers
%include "stl.i"
%include "exception.i"

%{
#define SWIG_FILE_WITH_INIT
#include "TooBigException.h"
#include "numbers.h"
%}

%exception {
    try {
        $action
    }
    catch (const numbers::TooBigException & e) {
        // This catches any self-defined exception in the exception hierarchy,
        // because they all derive from this base class. 
        <TODO>
    }
    catch (const std::exception & e)
    {
        SWIG_exception(SWIG_RuntimeError, (std::string("C++ std::exception: ") + e.what()).c_str());
    }
    catch (...)
    {
        SWIG_exception(SWIG_UnknownError, "C++ anonymous exception");
    }
}

%include "TooBigException.h"
%include "numbers.h"

したがって、API へのすべての呼び出しは、try-catch ブロックによってラップされます。基本型の最初の例外がキャッチされ、処理されます。次に、他のすべての例外がキャッチされ、SWIG 例外ライブラリを使用して再スローされます。

のサブクラスnumbers::TooBigExceptionがキャッチされ、常にTooBigException!

Linux マシンで次のコマンドを実行すると、プロジェクトを簡単にビルドできます。

$ swig -c++ -python numbers.i
$ g++ -fPIC -shared TooBigException.cpp numbers.cpp numbers_wrap.cxx \
    -I/usr/include/python2.7 -o _numbers.so

現在の実装

私の現在の実装では、まだ (正常に) 固定の標準 Python 例外がスローされます。上記のコード<TODO>は次のように置き換えられます。

PyErr_SetString(PyExc_Exception, (std::string("C++ self-defined exception ") + e.what()).c_str());
return NULL;

これにより、Python で次の (予想される) 動作が得られます。

>>> import numbers
>>> fact(11)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Exception: C++ self-defined exception Value too big
4

2 に答える 2

9

swig-userリストで誰かがあなたの基本的な質問に答えたようです...

%exception {
  try {
    $action
  } catch (MyException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj(
            (new MyException(static_cast<const MyException& >(_e))),  
            SWIGTYPE_p_MyException,SWIG_POINTER_OWN),
        "MyException", SWIGTYPE_p_MyException); 
    SWIG_fail;
  } 
}

これは、例外クラスのラッパーを生成したことを前提としています。

于 2013-02-22T13:54:45.880 に答える
6

階層の例

std::exception
  -> API::Exception
    -> API::NetworkException
      -> API::TimeoutException
      -> API::UnreachableException
    -> API::InvalidAddressException

example.i:

%module example
%include "stl.i"
%include "exception.i"

%{
#define SWIG_FILE_WITH_INIT
#include "example.cpp"
%}

%{

#define CATCH_PE(Namespace,Exception) \
    catch(const Namespace::Exception &e) \
    { \
       SWIG_Python_Raise(SWIG_NewPointerObj(new Namespace::Exception(e), \
            SWIGTYPE_p_##Namespace##__##Exception,SWIG_POINTER_OWN), \
            #Exception, SWIGTYPE_p_##Namespace##__##Exception); \
       SWIG_fail; \
    } \
/**/

// should be in "derived first" order
#define FOR_EACH_EXCEPTION(ACTION) \
   ACTION(API,UnreachableException) \
   ACTION(API,TimeoutException) \
   ACTION(API,InvalidAddressException) \
   ACTION(API,NetworkException) \
   ACTION(API,Exception) \
/**/
// In order to remove macros, need traits:
// http://swig.10945.n7.nabble.com/traits-based-access-to-swig-type-info-td12315.html
%}

%exception {
    try {
        $action
    }
    FOR_EACH_EXCEPTION(CATCH_PE)
    catch (const std::exception & e)
    {
        SWIG_exception(SWIG_RuntimeError, (std::string("C++ std::exception: ") + e.what()).c_str());
    }
    catch (...)
    {
        SWIG_exception(SWIG_UnknownError, "C++ anonymous exception");
    }
}

%include "example.cpp"

例.cpp:

#include <exception>
#include <stdexcept>

namespace API
{
    struct Exception: std::exception
    {
        virtual const char* what() const throw()
        {
            return "It is API::Exception";
        }
    };
    struct NetworkException: Exception
    {
        virtual const char* what() const throw()
        {
            return "It is API::NetworkException";
        }
    };
    struct TimeoutException: NetworkException
    {
        virtual const char* what() const throw()
        {
            return "It is API::TimeoutException";
        }
    };
    struct UnreachableException: NetworkException
    {
        virtual const char* what() const throw()
        {
            return "It is API::UnreachableException";
        }
    };
    struct InvalidAddressException: Exception
    {
        virtual const char* what() const throw()
        {
            return "It is API::InvalidAddressException";
        }
    };

    inline void select(int i)
    {
        switch(i)
        {
            case 0: throw Exception();
            case 1: throw NetworkException();
            case 2: throw TimeoutException();
            case 3: throw UnreachableException();
            case 4: throw InvalidAddressException();
            default: throw std::runtime_error("It is std::runtime_error");
        }
    }
}

建てる：

swig -c++ -python example.i &&
g++ -fPIC -shared -lpython2.7 example.cpp example_wrap.cxx -I/usr/include/python2.7 -o _example.so

test.py:

#!/usr/bin/env python2.7

from exceptions import BaseException
from example import *

def catch(i):
    try:
        select(i)
    except UnreachableException as e:
        print "Caught UnreachableException"
        print e.what()
        print e
    except TimeoutException as e:
        print "Caught TimeoutException"
        print e.what()
        print e
    except InvalidAddressException as e:
        print "Caught InvalidAddressException"
        print e.what()
        print e
    except NetworkException as e:
        print "Caught NetworkException"
        print e.what()
        print e
    except Exception as e:
        print "Caught Exception"
        print e.what()
        print e
    except BaseException as e:
        print "Caught BaseException"
        print str(e)
    print "_"*16

for i in xrange(6):
    catch(i)

出力は次のとおりです。

Caught Exception
It is API::Exception
<example.Exception; proxy of <Swig Object of type 'API::Exception *' at 0x7f9f54a02120> >
________________
Caught NetworkException
It is API::NetworkException
<example.NetworkException; proxy of <Swig Object of type 'API::NetworkException *' at 0x7f9f54a02120> >
________________
Caught TimeoutException
It is API::TimeoutException
<example.TimeoutException; proxy of <Swig Object of type 'API::TimeoutException *' at 0x7f9f54a02120> >
________________
Caught UnreachableException
It is API::UnreachableException
<example.UnreachableException; proxy of <Swig Object of type 'API::UnreachableException *' at 0x7f9f54a02120> >
________________
Caught InvalidAddressException
It is API::InvalidAddressException
<example.InvalidAddressException; proxy of <Swig Object of type 'API::InvalidAddressException *' at 0x7f9f54a02120> >
________________
Caught BaseException
C++ std::exception: It is std::runtime_error
________________

maillist の回答に基づいています。

于 2013-04-03T00:51:08.257 に答える