lsst::pex::exceptions Namespace Reference

Namespaces
namespace	python
namespace	version
namespace	wrappers

Classes
class	DomainError
	Reports arguments outside the domain of an operation. More...
class	Exception
	Provides consistent interface for LSST exceptions. More...
class	InvalidParameterError
	Reports invalid arguments. More...
class	IoError
	Reports errors in external input/output operations. More...
class	LengthError
	Reports attempts to exceed implementation-defined length limits for some classes. More...
class	LogicError
	Reports errors in the logical structure of the program. More...
class	NotFoundError
	Reports attempts to access elements using an invalid key. More...
class	OutOfRangeError
	Reports attempts to access elements outside a valid range of indices. More...
class	OverflowError
	Reports when the result of an arithmetic operation is too large for the destination type. More...
class	RangeError
	Reports when the result of an operation cannot be represented by the destination type. More...
class	RuntimeError
	Reports errors that are due to events beyond the control of the program. More...
struct	Tracepoint
	One point in the Traceback vector held by Exception. More...
class	TypeError
	Reports errors from accepting an object of an unexpected or inappropriate type. More...
class	UnderflowError
	Reports when the result of an arithmetic operation is too small for the destination type. More...

Typedefs
typedef std::vector< Tracepoint >	Traceback

Functions
std::ostream &	operator<< (std::ostream &stream, Exception const &e)
	Push the text representation of an exception onto a stream. More...
	PYBIND11_MODULE (exceptions, mod)

Typedef Documentation

Traceback

typedef std::vector<Tracepoint> lsst::pex::exceptions::Traceback

Definition at line 95 of file Exception.h.

Function Documentation

operator<<()

std::ostream & lsst::pex::exceptions::operator<<	(	std::ostream &	stream,
		Exception const &	e
	)

Push the text representation of an exception onto a stream.

Parameters

[in]	stream	Reference to an output stream.
[in]	e	Exception to output.

Returns

Reference to the output stream after adding the text.

Definition at line 105 of file Exception.cc.

{ return e.addToStream(stream); }

PYBIND11_MODULE()

lsst::pex::exceptions::PYBIND11_MODULE	(	exceptions	,
		mod
	)

Definition at line 90 of file exceptions.cc.

                                 {
    py::class_<Tracepoint> clsTracepoint(mod, "Tracepoint");
 
    clsTracepoint.def(py::init<char const *, int, char const *, std::string const &>())
            .def_readwrite("_file", &Tracepoint::_file)
            .def_readwrite("_line", &Tracepoint::_line)
            .def_readwrite("_func", &Tracepoint::_func)
            .def_readwrite("_message", &Tracepoint::_message);
 
    py::class_<Exception> clsException(mod, "Exception");
 
    clsException.def(py::init<std::string const &>())
            .def("addMessage", &Exception::addMessage)
            .def("getTraceback", &Exception::getTraceback)
            .def("addToStream", &Exception::addToStream)
            .def("what", &Exception::what)
            .def("getType", &Exception::getType)
            .def("clone", &Exception::clone)
            .def("asString",
                 [](Exception &self) -> std::string {
                     std::ostringstream stream;
                     self.addToStream(stream);
                     return stream.str();
                 })
            .def("__repr__", [](Exception &self) -> std::string {
                std::stringstream s;
                s << "Exception('" << self.what() << "')";
                return s.str();
            });
 
    py::class_<LogicError, Exception> clsLogicError(mod, "LogicError");
    clsLogicError.def(py::init<std::string const &>());
 
    py::class_<NotFoundError, Exception> clsNotFoundError(mod, "NotFoundError");
    clsNotFoundError.def(py::init<std::string const &>());
 
    py::class_<RuntimeError, Exception> clsRuntimeError(mod, "RuntimeError");
    clsRuntimeError.def(py::init<std::string const &>());
 
    py::class_<IoError, RuntimeError> clsIoError(mod, "IoError");
    clsIoError.def(py::init<std::string const &>());
 
    py::class_<OverflowError, RuntimeError> clsOverflowError(mod, "OverflowError");
    clsOverflowError.def(py::init<std::string const &>());
 
    py::class_<RangeError, RuntimeError> clsRangeError(mod, "RangeError");
    clsRangeError.def(py::init<std::string const &>());
 
    py::class_<TypeError, LogicError> clsTypeError(mod, "TypeError");
    clsTypeError.def(py::init<std::string const &>());
 
    py::class_<UnderflowError, RuntimeError> clsUnderflowError(mod, "UnderflowError");
    clsUnderflowError.def(py::init<std::string const &>());
 
    py::class_<DomainError, LogicError> clsDomainError(mod, "DomainError");
    clsDomainError.def(py::init<std::string const &>());
 
    py::class_<InvalidParameterError, LogicError> clsInvalidParameterError(mod, "InvalidParameterError");
    clsInvalidParameterError.def(py::init<std::string const &>());
 
    py::class_<LengthError, LogicError> clsLengthError(mod, "LengthError");
    clsLengthError.def(py::init<std::string const &>());
 
    py::class_<OutOfRangeError, LogicError> clsOutOfRangeError(mod, "OutOfRangeError");
    clsOutOfRangeError.def(py::init<std::string const &>());
 
    py::register_exception_translator([](std::exception_ptr p) {
        try {
            if (p) std::rethrow_exception(p);
        } catch (const Exception &e) {
            py::object current_exception;
            current_exception = py::cast(e.clone(), py::return_value_policy::take_ownership);
            raiseLsstException(current_exception);
        }
    });
}