1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
#pragma once
#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <util/generic/yexception.h>
#include <util/generic/map.h>
#include <util/generic/vector.h>
#include "ptr.h"
namespace NPyBind {
// Usage:
// ythrow TPyErr(PyExc_TypeError) << "some python type error somewhere in your C++ code";
//
class TPyErr: public virtual yexception {
public:
TPyErr(PyObject* theException = PyExc_RuntimeError)
: Exception(theException)
{
}
TPyObjectPtr GetException() const {
return Exception;
}
private:
NPyBind::TPyObjectPtr Exception;
};
//Private api for creating PyBind python module
//Needs only for overriding pybind python module in library which imports other pybind library
namespace NPrivate {
TPyObjectPtr CreatePyBindModule();
}//NPrivate
class TExceptionsHolder {
friend TPyObjectPtr NPrivate::CreatePyBindModule();
private:
TExceptionsHolder(const TExceptionsHolder&);
TExceptionsHolder& operator=(const TExceptionsHolder&);
TExceptionsHolder();
void Clear();
TPyObjectPtr GetException(const TString&);
TPyObjectPtr GetExceptions(const TVector<TString>&);
private:
class TExceptionsChecker {
public:
virtual ~TExceptionsChecker() {
}
virtual bool Check(const std::exception& ex) const = 0;
virtual TString GetName() const = 0;
virtual TPyObjectPtr GetException() const = 0;
};
template <typename TExcType>
class TConcreteExceptionsChecker: public TExceptionsChecker {
private:
TString Name;
TPyObjectPtr Exception;
public:
TConcreteExceptionsChecker(const TString& name, TPyObjectPtr exception)
: Name(name)
, Exception(exception)
{
}
bool Check(const std::exception& ex) const override {
const std::exception* e = &ex;
return dynamic_cast<const TExcType*>(e);
}
TString GetName() const override {
return Name;
}
TPyObjectPtr GetException() const override {
return Exception;
}
};
class TPyErrExceptionsChecker: public TExceptionsChecker {
private:
mutable TPyObjectPtr Exception;
public:
TPyErrExceptionsChecker() {
}
bool Check(const std::exception& ex) const override {
const TPyErr* err = dynamic_cast<const TPyErr*>(&ex);
if (err) {
Exception = err->GetException();
}
return err != nullptr;
}
TString GetName() const override {
return TString();
}
TPyObjectPtr GetException() const override {
return Exception;
}
};
typedef TSimpleSharedPtr<TExceptionsChecker> TCheckerPtr;
typedef TVector<TCheckerPtr> TCheckersVector;
typedef TMap<TString, TPyObjectPtr> TExceptionsMap;
TPyObjectPtr Module;
TCheckersVector Checkers;
TExceptionsMap Exceptions;
static PyObject* DoInitPyBindModule();
static void DoInitPyBindModule2();
public:
static TExceptionsHolder& Instance() {
static TExceptionsHolder Holder;
return Holder;
}
template <typename TExcType>
void AddException(const TString& name, const TString& base = "") {
TPyObjectPtr baseException(GetException(base));
TString fullName = TString("pybind.") + name;
TPyObjectPtr exception(PyErr_NewException(const_cast<char*>(fullName.c_str()), baseException.Get(), nullptr), true);
Checkers.push_back(new TConcreteExceptionsChecker<TExcType>(name, exception));
Exceptions[name] = exception;
}
template <typename TExcType>
void AddException(const TString& name, const TVector<TString>& bases) {
TPyObjectPtr baseExceptions(GetExceptions(bases));
TString fullName = TString("pybind.") + name;
TPyObjectPtr exception(PyErr_NewException(const_cast<char*>(fullName.c_str()), baseExceptions.Get(), nullptr), true);
Checkers.push_back(new TConcreteExceptionsChecker<TExcType>(name, exception));
Exceptions[name] = exception;
}
NPyBind::TPyObjectPtr ToPyException(const std::exception&);
};
}
|
