lsst::meas::base::MeasurementError Class Reference

Exception to be thrown when a measurement algorithm experiences a known failure mode. More...

#include <exceptions.h>

Inheritance diagram for lsst::meas::base::MeasurementError:

Public Member Functions
	MeasurementError (std::string const &message, std::size_t flagBit)
	Constructor; should only be invoked from Python macro. More...
	MeasurementError (LSST_EARGS_TYPED, std::size_t flagBit)
	Constructor; should only be invoked by the LSST_EXCEPT macro (see class docs) More...
std::size_t	getFlagBit () const
	Return the flag bit associated with the error. More...
virtual char const *	getType (void) const throw ()
	Return the fully-specified C++ type of a pointer to the exception. More...
virtual lsst::pex::exceptions::Exception *	clone (void) const
	Return a copy of the exception as an Exception pointer. More...
void	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). More...
Traceback const &	getTraceback (void) const noexcept
	Retrieve the list of tracepoints associated with an exception. More...
virtual std::ostream &	addToStream (std::ostream &stream) const
	Add a text representation of this exception, including its traceback with messages, to a stream. More...
virtual char const *	what (void) const noexcept
	Return a character string summarizing this exception. More...
T	what (T... args)

Detailed Description

Exception to be thrown when a measurement algorithm experiences a known failure mode.

In addition to the usual message, MeasurementError must be constructed with the bit of the algorithm-specific flag that indicates the known failure mode. This allows the measurement framework to set that flag upon failure. Typically, this flag bit is also used to look up the message from the algorithm classes FlagDefinition list; the common pattern is:

if (badThingHappened) {
    // BAD_THING is an enum value from the Algorithm's FlagBits enum; getFlagDefinitions()
    // is a static method algorithms are expected to define.
    throw LSST_EXCEPT(MeasurementError, getFlagDefinitions()[BAD_THING), BAD_THING);
 }

Definition at line 48 of file exceptions.h.

Constructor & Destructor Documentation

MeasurementError() [1/2]

lsst::meas::base::MeasurementError::MeasurementError ( std::string const &  message, std::size_t  flagBit  )

inline

Constructor; should only be invoked from Python macro.

Definition at line 51 of file exceptions.h.

            : pex::exceptions::RuntimeError(message), _flagBit(flagBit) {}

MeasurementError() [2/2]

lsst::meas::base::MeasurementError::MeasurementError ( LSST_EARGS_TYPED  , std::size_t  flagBit  )

inline

Constructor; should only be invoked by the LSST_EXCEPT macro (see class docs)

Definition at line 55 of file exceptions.h.

            : pex::exceptions::RuntimeError(LSST_EARGS_UNTYPED), _flagBit(flagBit) {}

Member Function Documentation

addMessage()

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

inherited

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 49 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();
}

addToStream()

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

virtualinherited

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 81 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;
}

clone()

virtual lsst::pex::exceptions::Exception* lsst::meas::base::MeasurementError::clone ( void  ) const

inlinevirtual

Return a copy of the exception as an Exception pointer.

Can be overridden by derived classes that add data or methods.

Returns

Pointer to a copy of the exception.

Reimplemented from lsst.pex::exceptions::Exception.

Definition at line 63 of file exceptions.h.

{ return new MeasurementError(*this); };

getFlagBit()

std::size_t lsst::meas::base::MeasurementError::getFlagBit ( ) const

inline

Return the flag bit associated with the error.

Definition at line 59 of file exceptions.h.

{ return _flagBit; }

getTraceback()

Traceback const & Exception::getTraceback ( void  ) const

noexceptinherited

Retrieve the list of tracepoints associated with an exception.

Definition at line 79 of file Exception.cc.

{ return _traceback; }

getType()

virtual char const* lsst::meas::base::MeasurementError::getType ( void  ) const throw ( )

inlinevirtual

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 Python interface.

Returns

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

Reimplemented from lsst.pex::exceptions::Exception.

Definition at line 61 of file exceptions.h.

{ return "lsst::meas::base::MeasurementError *"; };

what()

char const * Exception::what ( void  ) const

virtualnoexceptinherited

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 99 of file Exception.cc.

{ return _message.c_str(); }

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/meas_base/22.0.1-25-gb120d7b+8b5510f75f/include/lsst/meas/base/exceptions.h