lsst::pex::exceptions::python Namespace Reference

Functions
template<typename T , typename E = lsst::pex::exceptions::Exception>
pybind11::class_< T, E >	declareException (pybind11::module &mod, const std::string &name, const std::string &base)
	Helper function for pybind11, used to define new types of exceptions. More...

Function Documentation

declareException()

template<typename T , typename E = lsst::pex::exceptions::Exception>

pybind11::class_<T, E> lsst::pex::exceptions::python::declareException	(	pybind11::module &	mod,
		const std::string &	name,
		const std::string &	base
	)

Helper function for pybind11, used to define new types of exceptions.

While this function creates the class wrapper, the user is still responsible for adding all constructor and member wrappers to the returned py::class_ object.

Template Parameters

T	The C++ exception to wrap.
E	The C++ base class of T.

Parameters

[in]	mod	Module to insert the exception into.
[in]	name	Name of the exception in the module.
[in]	base	Python name of base class (from pex::exceptions).

Definition at line 52 of file Exception.h.

                                                            {
    namespace py = pybind11;
 
    // Wrap T as a new Python exception type with *name* and add it to the module
    //
    // Note that all created C++ wrapped type derive from Exception here.
    // It is only in the pure Python wrapper layer that they get embedded in
    // a subclass of the requested base.
    py::class_<T, E> cls(mod, name.c_str());
 
    // Declare T wrapped by cls as a pex exception and register it
    // this relies on the pure Python function "declare" defined in "wrappers"
    // to create a corresponding Python type derived from Python standard Exception
    auto exceptions =
            py::reinterpret_steal<py::object>(PyImport_ImportModule("lsst.pex.exceptions.wrappers"));
    if (!exceptions.ptr()) {
        PyErr_SetString(PyExc_SystemError, "import failed");
        throw py::error_already_set();
    }
 
    auto declare = py::reinterpret_steal<py::object>(PyObject_GetAttrString(exceptions.ptr(), "declare"));
    if (!declare.ptr()) {
        PyErr_SetString(PyExc_SystemError, "could not get declare function from Python");
        throw py::error_already_set();
    }
 
    auto baseCls = py::reinterpret_steal<py::object>(PyObject_GetAttrString(exceptions.ptr(), base.c_str()));
    if (!baseCls.ptr()) {
        PyErr_SetString(PyExc_SystemError, "could not get base class");
        throw py::error_already_set();
    }
 
    auto exceptionName = py::reinterpret_steal<py::object>(PYBIND11_FROM_STRING(name.c_str()));
    if (!exceptionName.ptr()) {
        PyErr_SetString(PyExc_SystemError, "could not create name string");
        throw py::error_already_set();
    }
 
    auto result = py::reinterpret_steal<py::object>(PyObject_CallFunctionObjArgs(
            declare.ptr(), mod.ptr(), exceptionName.ptr(), baseCls.ptr(), cls.ptr(), NULL));
    if (!result.ptr()) {
        PyErr_SetString(PyExc_SystemError, "could not declare exception");
        throw py::error_already_set();
    }
 
    return cls;
}