lsst::pex.exceptions::Exception Class Reference

#include <Exception.h>

Inheritance diagram for lsst::pex.exceptions::Exception:

Public Member Functions
	Exception (char const *file, int line, char const *func, std::string const &message)
	Exception (std::string const &message)
virtual	~Exception (void) throw ()
void	addMessage (char const *file, int line, char const *func, std::string const &message)
Traceback const &	getTraceback (void) const throw ()
	Retrieve the list of tracepoints associated with an exception. More...
virtual std::ostream &	addToStream (std::ostream &stream) const
virtual char const *	what (void) const throw ()
virtual char const *	getType (void) const throw ()
virtual Exception *	clone (void) const

Private Attributes
std::string	_message
Traceback	_traceback

Detailed Description

Definition at line 99 of file Exception.h.

Constructor & Destructor Documentation

Exception::Exception	(	char const *	file,
		int	line,
		char const *	func,
		std::string const &	message
	)

Standard constructor, intended for C++ use via the LSST_EXCEPT() macro.

Parameters

[in]	file	Filename (automatically passed in by macro).
[in]	line	Line number (automatically passed in by macro).
[in]	func	Function name (automatically passed in by macro).
[in]	message	Informational string attached to exception.

Definition at line 44 of file Exception.cc.

  : _message(message), _traceback(1, Tracepoint(file, line, func, message)) {}

Exception::Exception ( std::string const &  message )

explicit

Message-only constructor, intended for use from Python only.

While this constructor can be called from C++, it's better to use the LSST_EXCEPT macro there, which stores file/line/function information as well. In Python, however, that information is stored outside the exception, so we don't want to duplicate it, and hence this constructor is invoked instead.

Parameters

[in]

message

Informational string attached to exception.

Definition at line 49 of file Exception.cc.

  : _message(message), _traceback() {}

Exception::~Exception ( void  ) throw ( )

virtual

Definition at line 53 of file Exception.cc.

{}

Member Function Documentation

void Exception::addMessage	(	char const *	file,
		int	line,
		char const *	func,
		std::string const &	message
	)

Add a tracepoint and a message to an exception before rethrowing it (access via LSST_EXCEPT_ADD).

Parameters

[in]	file	Filename (automatically passed in by macro).
[in]	line	Line number (automatically passed in by macro).
[in]	func	Function name (automatically passed in by macro).
[in]	message	Additional message to associate with this rethrow.

Definition at line 55 of file Exception.cc.

  {
    std::ostringstream stream;
    stream << _message;
    if (_traceback.empty()) {
        // This means the message-only constructor was used, which should only happen
        // from Python...but this method isn't accessible from Python, so maybe
        // this Exception was thrown in Python, then passed back to C++.  Or, more
        // likely, someone didn't read the warning and threw this exception in C++
        // without using LSST_EXCEPT.
        // But, because we don't have a traceback for that first message, we can't
        // add one here without messing up the stringification logic later.  Since
        // this is a rare case (and should be considered a bug, but we don't want
        // exception code throwing its own exceptions unless it absolutely has to),
        // we'll proceed by just appending the message and ignoring the traceback.
        stream << "; " << message;
    } else {
        if (_traceback.size() == static_cast<std::size_t>(1)) {
            // The original message doesn't have an index (because it's faster,
            // and there's no need if there's only one), so when we add the second,
            // we have to give it an index.
            stream << " {0}; ";
        } else {
            stream << "; ";
        }
        stream << message << " {" << _traceback.size() << "}";
        _traceback.push_back(Tracepoint(file, line, func, message));
    }
    _message = stream.str();

}

std::ostream & Exception::addToStream ( std::ostream &  stream ) const

virtual

Add a text representation of this exception, including its traceback with messages, to a stream.

Parameters

[in]

stream

Reference to an output stream.

Returns

Reference to the output stream after adding the text.

Definition at line 93 of file Exception.cc.

                                                           {
    if (_traceback.empty()) {
        // The exception was raised in Python, so we don't include the traceback, the type, or any
        // newlines, because Python will print those itself.
        stream << _message;
    } else {
        stream << std::endl; // Start with a newline to separate our stuff from Pythons "<type>: " prefix.
        for (std::size_t i = 0; i != _traceback.size(); ++i) {
            stream << "  File \"" << _traceback[i]._file
                   << "\", line " << _traceback[i]._line
                   << ", in " << _traceback[i]._func << std::endl;
            stream << "    " << _traceback[i]._message << " {" << i << "}" << std::endl;
        }
        std::string type(getType(), 0, std::strlen(getType()) - 2);
        stream << type << ": '" << _message << "'" << std::endl;
    }
    return stream;
}

Exception * Exception::clone ( void  ) const

virtual

Return a copy of the exception as an Exception*. Can be overridden by derived classes that add data or methods.

Returns

Exception* pointing to a copy of the exception.

Definition at line 120 of file Exception.cc.

                                      {
    return new Exception(*this);
}

Traceback const & Exception::getTraceback	(	void		)	const
throw	(
	)

Retrieve the list of tracepoints associated with an exception.

Definition at line 89 of file Exception.cc.

                                              {
    return _traceback;
}

char const * Exception::getType ( void  ) const throw ( )

virtual

Return the fully-specified C++ type of a pointer to the exception. This is overridden by derived classes (automatically if the LSST_EXCEPTION_TYPE macro is used). It is used by the SWIG interface.

Returns

String with the C++ type; does not need to be freed/deleted.

Definition at line 116 of file Exception.cc.

                                                 {
    return "lsst::pex::exceptions::Exception *";
}

char const * Exception::what ( void  ) const throw ( )

virtual

Return a character string summarizing this exception.

This combines all the messages added to the exception, but not the type or traceback (use the stream operator to get this more detailed information).

Not allowed to throw any exceptions.

Returns

String representation; does not need to be freed/deleted.

Definition at line 112 of file Exception.cc.

                                              {
    return _message.c_str();
}

Member Data Documentation

std::string lsst::pex.exceptions::Exception::_message

private

Definition at line 174 of file Exception.h.

Traceback lsst::pex.exceptions::Exception::_traceback

private

Definition at line 175 of file Exception.h.

---

The documentation for this class was generated from the following files:

• /home/lsstsw/stack/Linux64/pex_exceptions/10.0+46/include/lsst/pex/exceptions/Exception.h
• /home/lsstsw/stack/Linux64/pex_exceptions/10.0+46/src/Exception.cc