doxygen/html/FMTExceptionHandler_8h_source.html

/*

Copyright (c) 2019 Gouvernement du Québec


SPDX-License-Identifier: LiLiQ-R-1.1

License-Filename: LICENSES/EN/LiLiQ-R11unicode.txt

*/


#ifndef FMTexceptionhandler_Hm_included

#define FMTexceptionhandler_Hm_included


#include "FMTLogger.h"

#include <unordered_map>

#include <boost/serialization/serialization.hpp>

#include <boost/serialization/nvp.hpp>

#include <boost/serialization/export.hpp>

#include <memory>

#include <set>

#include <boost/thread.hpp>

#if defined _MSC_VER

    #include "FMTScopedSeTranslator.h"

#endif


namespace Exception

{

    class FMTException;

    class FMTWarning;

    // DocString: FMTExceptionHandler

    class FMTEXPORT FMTExceptionHandler

    {

    public:

        // DocString: checkSignals()

        void checkSignals() const;

        // DocString: FMTExceptionHandler()

        FMTExceptionHandler();

        // DocString: ~FMTExceptionHandler()

        virtual ~FMTExceptionHandler() = default;

        // DocString: FMTExceptionHandler(const FMTExceptionHandler&)

        FMTExceptionHandler(const FMTExceptionHandler& rhs);

        // DocString: FMTExceptionHandler(const std::unique_ptr<Logging::FMTLogger>&)

        FMTExceptionHandler(const std::unique_ptr<Logging::FMTLogger>& logger);

        // DocString: FMTExceptionHandler::passInLogger

        void passInLogger(const std::unique_ptr<Logging::FMTLogger>& logger);


        // DocString: FMTExceptionHandler::getCplData

        virtual FMTExceptionHandler* getCplData();

        #if defined FMTWITHGDAL

                // DocString: FMTExceptionHandler::handelCplError

                virtual void handelCplError(int eErrClass, int nError, const char* pszErrorMsg);

        #endif

        // DocString: FMTExceptionHandler::operator=

        FMTExceptionHandler& operator = (const FMTExceptionHandler& rhs);

        // DocString: FMTExceptionHandler::throwNested

        void throwNested(const std::exception& texception, int& level, bool rethrow = true);

        // DocString: FMTExceptionHandler::printExceptions

        virtual void printExceptions(std::string text,

            const std::string& method, const int& line, const std::string& fil,

            Core::FMTsection lsection = Core::FMTsection::Empty);

        // DocString: FMTExceptionHandler::raise

        virtual FMTException raise(FMTexc lexception, std::string text,

            const std::string& method, const int& line, const std::string& file,

            Core::FMTsection lsection = Core::FMTsection::Empty, bool throwit = true);

        // DocString: FMTExceptionHandler::raiseFromCatch

        virtual FMTException raiseFromCatch(std::string text,

            const std::string& method, const int& line, const std::string& file,

            Core::FMTsection lsection = Core::FMTsection::Empty);

        // DocString: FMTExceptionHandler::raiseFromThreadCatch

        void raiseFromThreadCatch(std::string text,

            const std::string& method, const int& line, const std::string& file,

            Core::FMTsection lsection = Core::FMTsection::Empty);

        // DocString: FMTExceptionHandler::reRaiseIfThreadCrash

        void reRaiseIfThreadCrash();

        // DocString: FMTExceptionHandler::enableNestedExceptions

        void enableNestedExceptions();

        // DocString: FMTExceptionHandler::disableNestedExceptions

        void disableNestedExceptions();

        // DocString: setErrorsToWarnings()

        void setErrorsToWarnings(const std::vector<Exception::FMTexc>& errors);

        // DocString: setMaxWarningsBeforeSilenced()

        void setMaxWarningsBeforeSilenced(const size_t& maxwarningcount);

        // DocString: FMTExceptionHandler::clone

        virtual std::unique_ptr <FMTExceptionHandler> clone() const = 0;

        #if defined _MSC_VER

        // DocString: FMTExceptionHandler::translateStructuralWIN32Exceptions

        static void translateStructuralWIN32Exceptions(unsigned int p_u, EXCEPTION_POINTERS*);

        #endif

        // DocString: getErrorDescription(bool,FMTexc)

        static std::string getErrorDescription(bool p_french, FMTexc p_type);

        // DocString: getErrorsToIgnore

        static std::vector<FMTexc> getErrorsToIgnore();

    protected:

        // DocString: FMTExceptionHandler::_exception

        FMTexc _exception;

        // DocString: FMTExceptionHandler::_errorcount

        int _errorcount;

        // DocString: FMTExceptionHandler::m_maxwarningsbeforesilenced

        size_t m_maxwarningsbeforesilenced;

        // DocString: FMTExceptionHandler::_logger

        Logging::FMTLogger* _logger;

        // DocString: FMTExceptionHandler::m_usenestedexceptions

        bool m_usenestedexceptions;

        // DocString: FMTExceptionHandler::m_mtx

        //mutable std::recursive_mutex mtx;

        mutable boost::recursive_mutex m_mtx;

        // DocString: FMTExceptionHandler::m_errorstowarnings

        std::vector<Exception::FMTexc>m_errorstowarnings;

        // DocString: FMTExceptionHandler::registred_threads

        std::set<boost::thread::id> m_registered_threads;

        // DocString: FMTExceptionHandler::m_mainthreadid

        static boost::thread::id m_mainthreadid;

        // DocString: FMTExceptionHandler::m_crashedthreadid

        static boost::thread::id m_crashedthreadid;

        // DocString: FMTExceptionHandler::threadcrashexceptions

        std::exception_ptr m_threadcrashexception;

        // DocString: FMTExceptionHandler::_updateStatus

        void _updateStatus(std::unique_ptr<FMTException>& p_exception);

        // DocString: FMTExceptionHandler(FMTexc,Core::FMTsection,const std::string&,const std::string&,const std::string&,int)

        static std::unique_ptr<FMTException> _createException(FMTexc p_exception, Core::FMTsection p_section, const std::string& p_message,

            const std::string& p_method, const std::string& p_file, int p_line);

        // DocString: FMTExceptionHandler::_needToRethrow

        bool _needToRethrow() const;

        // DocString: FMTExceptionHandler::_isMainThread()

        bool _isMainThread() const;

        // DocString: FMTExceptionHandler::_isThrowedOnThread()

        bool _isThrowedOnThread() const;

        // DocString: FMTExceptionHandler::_isThisThreadThrowed()

        bool _isThisThreadThrowed() const;

        // DocString: FMTExceptionHandler::registerthread

        void _registerWorkerThread();

        // DocString: FMTExceptionHandler::isregistered

        bool _isThreadRegistered() const;

        // DocString: FMTExceptionHandler::_gutsOfPrintExceptions

        void _gutsOfPrintExceptions(std::string text,

            const std::string& method, const int& line, const std::string& fil,

            int& levelreference,Core::FMTsection lsection = Core::FMTsection::Empty,bool logfirstlevel = true);

        // DocString: FMTExceptionHandler::_gutsOfExceptionLog

        void _gutsOfExceptionLog(const std::exception& texception,const int& level);

        // DocString: FMTExceptionHandler::_updateWarningCount

        void _updateWarningCount(const FMTException& p_warning);

    private:

        // DocString: FMTExceptionHandler::serialize

        friend class boost::serialization::access;

        template<class Archive>

        void serialize(Archive& ar, const unsigned int version)

        {

            ar& BOOST_SERIALIZATION_NVP(_exception);

            ar& BOOST_SERIALIZATION_NVP(_logger);

            ar& BOOST_SERIALIZATION_NVP(m_usenestedexceptions);

        }

        #if defined _MSC_VER

        // DocString: FMTScopedSeTranslator::m_SeTranslator

        static FMTScopedSeTranslator m_SeTranslator;

        #endif

        // DocString: FMTExceptionHandler::_specificwarningcount

        std::unordered_map<FMTexc, size_t> m_specificwarningcount;


    };


}


BOOST_CLASS_EXPORT_KEY(Exception::FMTExceptionHandler)


#endif

FMTLogger.h

FMTScopedSeTranslator.h

FMTEXPORT
#define FMTEXPORT
Definition: FMTutility.h:125

Exception::FMTExceptionHandler
Base class used to handle errors thrown in FMT.
Definition: FMTExceptionHandler.h:34

Exception::FMTExceptionHandler::m_mainthreadid
static boost::thread::id m_mainthreadid
Main thread id.
Definition: FMTExceptionHandler.h:236

Exception::FMTExceptionHandler::m_errorstowarnings
std::vector< Exception::FMTexc > m_errorstowarnings
If an error is in this list it's going to processed like a warning.
Definition: FMTExceptionHandler.h:230

Exception::FMTExceptionHandler::m_crashedthreadid
static boost::thread::id m_crashedthreadid
The thread id of the crashed thread.
Definition: FMTExceptionHandler.h:239

Exception::FMTExceptionHandler::_logger
Logging::FMTLogger * _logger
pointer to the logger used to print the warning / error.
Definition: FMTExceptionHandler.h:220

Exception::FMTExceptionHandler::FMTExceptionHandler
FMTExceptionHandler()
Default constructor for FMTExceptionHandler.

Exception::FMTExceptionHandler::_gutsOfPrintExceptions
void _gutsOfPrintExceptions(std::string text, const std::string &method, const int &line, const std::string &fil, int &levelreference, Core::FMTsection lsection=Core::FMTsection::Empty, bool logfirstlevel=true)
The guts of printExceptions.

Exception::FMTExceptionHandler::setErrorsToWarnings
void setErrorsToWarnings(const std::vector< Exception::FMTexc > &errors)
Set a list of errors to be cast to warnings.

Exception::FMTExceptionHandler::m_registered_threads
std::set< boost::thread::id > m_registered_threads
This is the level of the last FMTException thrown by the FMTExceptionHandler.
Definition: FMTExceptionHandler.h:233

Exception::FMTExceptionHandler::_registerWorkerThread
void _registerWorkerThread()
Register a worker thread so the handler knows it is dealing with a slave thread and not the main one.

Exception::FMTExceptionHandler::raise
virtual FMTException raise(FMTexc lexception, std::string text, const std::string &method, const int &line, const std::string &file, Core::FMTsection lsection=Core::FMTsection::Empty, bool throwit=true)
Throw a FMTException based on the exception type, section, message and source location....

Exception::FMTExceptionHandler::getErrorsToIgnore
static std::vector< FMTexc > getErrorsToIgnore()
gives you a vector of error you can safely turn into warning using setErrorsToWarning return a vector...

Exception::FMTExceptionHandler::m_mtx
boost::recursive_mutex m_mtx
Mutex for multi-threading.
Definition: FMTExceptionHandler.h:227

Exception::FMTExceptionHandler::checkSignals
void checkSignals() const
Check signals in R and Python if on the main thread.

Exception::FMTExceptionHandler::raiseFromThreadCatch
void raiseFromThreadCatch(std::string text, const std::string &method, const int &line, const std::string &file, Core::FMTsection lsection=Core::FMTsection::Empty)
Raise an exception from a catch body on a worker thread, catching all exceptions and printing them wi...

Exception::FMTExceptionHandler::_gutsOfExceptionLog
void _gutsOfExceptionLog(const std::exception &texception, const int &level)
The guts of logging exceptions.

Exception::FMTExceptionHandler::setMaxWarningsBeforeSilenced
void setMaxWarningsBeforeSilenced(const size_t &maxwarningcount)
Setter for the maximum number of warnings before they are silenced.

Exception::FMTExceptionHandler::_isThreadRegistered
bool _isThreadRegistered() const
Return true if the thread is registered.

Exception::FMTExceptionHandler::FMTExceptionHandler
FMTExceptionHandler(const std::unique_ptr< Logging::FMTLogger > &logger)
Construct a FMTExceptionHandler with a logger.

Exception::FMTExceptionHandler::reRaiseIfThreadCrash
void reRaiseIfThreadCrash()
Re-raise a multithread error if an exception was raised by any thread.

Exception::FMTExceptionHandler::disableNestedExceptions
void disableNestedExceptions()
Disable the throwing of nested exceptions.

Exception::FMTExceptionHandler::m_usenestedexceptions
bool m_usenestedexceptions
If usenested = true then the handler will throw nested exceptions.
Definition: FMTExceptionHandler.h:223

Exception::FMTExceptionHandler::_isThisThreadThrowed
bool _isThisThreadThrowed() const
Return true if this thread has thrown.

Exception::FMTExceptionHandler::_updateWarningCount
void _updateWarningCount(const FMTException &p_warning)
update the warning count and print if max not reached

Exception::FMTExceptionHandler::getCplData
virtual FMTExceptionHandler * getCplData()
Return a copy of the abstract handler for use in the FMTCPLErrorHandler function when using GDAL.

Exception::FMTExceptionHandler::FMTExceptionHandler
FMTExceptionHandler(const FMTExceptionHandler &rhs)
Copy constructor for FMTExceptionHandler.

Exception::FMTExceptionHandler::_errorcount
int _errorcount
Keeps count of the number of error thrown.
Definition: FMTExceptionHandler.h:214

Exception::FMTExceptionHandler::getErrorDescription
static std::string getErrorDescription(bool p_french, FMTexc p_type)
get descriptions of the potential errors

Exception::FMTExceptionHandler::handelCplError
virtual void handelCplError(int eErrClass, int nError, const char *pszErrorMsg)
Callback called by GDAL for handling GDAL errors thrown.

Exception::FMTExceptionHandler::raiseFromCatch
virtual FMTException raiseFromCatch(std::string text, const std::string &method, const int &line, const std::string &file, Core::FMTsection lsection=Core::FMTsection::Empty)
Raise an exception from a catch body, determining if the exception is unhandled.

Exception::FMTExceptionHandler::m_threadcrashexception
std::exception_ptr m_threadcrashexception
The exception throwed by the faulty thread...
Definition: FMTExceptionHandler.h:242

Exception::FMTExceptionHandler::throwNested
void throwNested(const std::exception &texception, int &level, bool rethrow=true)
Throw a nested exception.

Exception::FMTExceptionHandler::enableNestedExceptions
void enableNestedExceptions()
Enable the throwing of nested exceptions.

Exception::FMTExceptionHandler::printExceptions
virtual void printExceptions(std::string text, const std::string &method, const int &line, const std::string &fil, Core::FMTsection lsection=Core::FMTsection::Empty)
Print all nested exceptions starting with the first provided.

Exception::FMTExceptionHandler::_needToRethrow
bool _needToRethrow() const
Return true if nested exceptions are used and the exception is a function error that must be rethrown...

Exception::FMTExceptionHandler::_isMainThread
bool _isMainThread() const
Return true if we are on the main thread.

Exception::FMTExceptionHandler::passInLogger
void passInLogger(const std::unique_ptr< Logging::FMTLogger > &logger)
Pass a logger to the shared pointer of the handler for sharing.

Exception::FMTExceptionHandler::clone
virtual std::unique_ptr< FMTExceptionHandler > clone() const =0
clone the FMTExceptionHandler

Exception::FMTExceptionHandler::m_maxwarningsbeforesilenced
size_t m_maxwarningsbeforesilenced
Number of time that the handler throw a certain warning before stop throwing it.
Definition: FMTExceptionHandler.h:217

Exception::FMTExceptionHandler::~FMTExceptionHandler
virtual ~FMTExceptionHandler()=default
Default virtual destructor for FMTExceptionHandler.

Exception::FMTExceptionHandler::_createException
static std::unique_ptr< FMTException > _createException(FMTexc p_exception, Core::FMTsection p_section, const std::string &p_message, const std::string &p_method, const std::string &p_file, int p_line)
Construct a FMTException from an exception type, a section, a message and the location where it occur...

Exception::FMTExceptionHandler::_updateStatus
void _updateStatus(std::unique_ptr< FMTException > &p_exception)
Update the status of the handler of the last exception type thrown and modify if it as to be ignored.

Exception::FMTExceptionHandler::_exception
FMTexc _exception
This is the type of the last FMTException thrown by the FMTExceptionHandler.
Definition: FMTExceptionHandler.h:211

Exception::FMTExceptionHandler::_isThrowedOnThread
bool _isThrowedOnThread() const
Return true if an exception has been thrown on a thread.

Exception::FMTException
Base exception class for FMT holding the type, section and message of a given exception.
Definition: FMTException.h:140

Exception::FMTScopedSeTranslator
RAII helper that installs a structured exception translator for its scope on MSVC.
Definition: FMTScopedSeTranslator.h:26

Logging::FMTLogger
Base class handling the level of information printed by FMT.
Definition: FMTLogger.h:37

Core::FMTsection
FMTsection
Enumerator describing the sections of a Woodstock model.
Definition: FMTutility.h:32

Core::Empty
@ Empty
Definition: FMTutility.h:44

Exception
Namespace for exceptions and exceptions handling (warnings and errors) thrown by FMT and all exceptio...
Definition: FMTAggregateRedefinition.h:11

Exception::FMTexc
FMTexc
Enumerator describing the exceptions thrown by FMT.
Definition: FMTException.h:45