doxygen/html/FMTObject_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 FMTobject_Hm_included

#define FMTobject_Hm_included


#ifndef NOMINMAX

    #define NOMINMAX

#endif // !NOMINMAX


#include <boost/serialization/unique_ptr.hpp>

#include <boost/serialization/nvp.hpp>

#include <boost/serialization/export.hpp>

#include "FMTException.h"

#include <memory>

#include <chrono>

#include <vector>


#if defined _MSC_VER || __MINGW64__ || __CYGWIN__


#else

    #include <boost/dll/runtime_symbol_info.h>

#endif


namespace Exception

{

    class FMTExceptionHandler;

}


namespace Logging

{

    class FMTLogger;

}


namespace Core

{

// DocString: FMTObject

class FMTEXPORT FMTObject

    {

    public:

        // DocString: FMTObject::getLogger

        static Logging::FMTLogger* getLogger();

        // DocString: FMTObject::getExceptionHandler

        static Exception::FMTExceptionHandler* getExceptionHandler();

        // DocString: FMTObject::getRuntimeLocation

        static std::string getRuntimeLocation();

        // DocString: FMTObject::getAvailableMemory

        static unsigned long long getAvailableMemory();

        // DocString: FMTObject()

        FMTObject();

        // DocString: ~FMTObject()

        virtual ~FMTObject();

        // DocString: FMTObject(const std::unique_ptr<Exception::FMTExceptionHandler>)

        FMTObject(const std::unique_ptr<Exception::FMTExceptionHandler> exhandler);

        // DocString: FMTObject(const FMTObject&)

        FMTObject(const FMTObject& rhs);

        // DocString: FMTObject::operator=

        FMTObject& operator = (const FMTObject& rhs);

        // DocString: FMTObject::passInLogger

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

        // DocString: FMTObject::passInExceptionHandler

        void passInExceptionHandler(const std::unique_ptr<Exception::FMTExceptionHandler>& exhandler);

        // DocString: FMTObject::redirectLogToFile

        void redirectLogToFile(const std::string& location);

        // DocString: FMTObject::setDefaultLogger

        virtual void setDefaultLogger();

        // DocString: FMTObject::setQuietLogger

        virtual void setQuietLogger();

        // DocString: FMTObject::setTaskLogger

        virtual void setTaskLogger();

        // DocString: FMTObject::setDebugLogger

        virtual void setDebugLogger();

        // DocString: FMTObject::setDefaultExceptionHandler

        void setDefaultExceptionHandler();

        // DocString: FMTObject::setQuietExceptionHandler

        void setQuietExceptionHandler();

        // DocString: FMTObject::setDebugExceptionHandler

        void setDebugExceptionHandler();

        // DocString: FMTObject::setFreeExceptionHandler

        void setFreeExceptionHandler();

        // DocString: FMTObject::disableNestedExceptions

        void disableNestedExceptions();

        // DocString: FMTObject::enableNestedExceptions

        void enableNestedExceptions();

        // DocString: FMTObject::setErrorsToWarnings

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

        // DocString: FMTObject::setMaxWarningsBeforeSilenced

        void setMaxWarningsBeforeSilenced(const size_t& maxwarningcount);

        // DocString: FMTExceptionHandler::setTerminateStack

        static void setTerminateStack();

        // DocString: FMTExceptionHandler::setAbortStack

        static void setAbortStack();

        // DocString: FMTObject::serialize

        friend class boost::serialization::access;

        template<class Archive>

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

        {

            //ar & BOOST_SERIALIZATION_NVP(_exhandler);

            //ar & BOOST_SERIALIZATION_NVP(_logger);

            //ar & BOOST_SERIALIZATION_NVP(m_section);

        }

    protected:

        // DocString: FMTObject::_exhandler

        static std::unique_ptr<Exception::FMTExceptionHandler> _exhandler;

        // DocString: FMTObject::_logger

        static std::unique_ptr<Logging::FMTLogger> _logger;

        // DocString: FMTObject:: forceSave

        template<class Archive>

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

        {

            //ar & BOOST_SERIALIZATION_NVP(_exhandler);

            //ar & BOOST_SERIALIZATION_NVP(_logger);

            //ar & BOOST_SERIALIZATION_NVP(m_section);

        }

        // DocString: FMTObject:: forceLoad

        template<class Archive>

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

        {

            //ar & BOOST_SERIALIZATION_NVP(_exhandler);

            //ar & BOOST_SERIALIZATION_NVP(_logger);

            setDefaultLogger();

            setDefaultExceptionHandler();

            //ar & BOOST_SERIALIZATION_NVP(m_section);

        }

        // DocString: FMTObject::checkSignals

        void checkSignals() const;

        // DocString: FMTObject::setCplHandler

        void setCplHandler();

        // DocString: FMTObject::getClock

        static std::chrono::time_point<std::chrono::high_resolution_clock> getClock();

        // DocString: FMTObject::getDuration

        template<class chrono>

        static double getDuration(const std::chrono::time_point<std::chrono::high_resolution_clock>& startclock);

        // DocString: FMTObject::getDurationInSeconds

        static std::string getDurationInSeconds(const std::chrono::time_point<std::chrono::high_resolution_clock>& startclock);

        // DocString: FMTExceptionHandler::_logStack

        static void _logStack();

        // DocString: FMTExceptionHandler::_terminate

        static void _terminate();

        // DocString: FMTExceptionHandler::_abort

        static void _abort(int p_signal);


    };

}

BOOST_SERIALIZATION_ASSUME_ABSTRACT(Core::FMTObject)

BOOST_CLASS_TRACKING(Core::FMTObject, boost::serialization::track_always)

BOOST_CLASS_EXPORT_KEY(Core::FMTObject)


#endif


FMTException.h

FMTEXPORT
#define FMTEXPORT
Definition: FMTutility.h:125

Core::FMTObject
Base class of multiple FMT classes holding a shared exception handler pointer and logger.
Definition: FMTObject.h:49

Core::FMTObject::getDurationInSeconds
static std::string getDurationInSeconds(const std::chrono::time_point< std::chrono::high_resolution_clock > &startclock)
Return the time elapsed since a start clock in seconds as a string.

Core::FMTObject::setQuietExceptionHandler
void setQuietExceptionHandler()
Create and set a quiet exception handler to the FMTObject.

Core::FMTObject::getLogger
static Logging::FMTLogger * getLogger()
get a pointer to the actual logger.

Core::FMTObject::forceSave
void forceSave(Archive &ar, const unsigned int version) const
Force the serialization to save useful information, which the default FMTObject serialization does no...
Definition: FMTObject.h:224

Core::FMTObject::getExceptionHandler
static Exception::FMTExceptionHandler * getExceptionHandler()
get a pointer to the actual exception handler.

Core::FMTObject::setDebugLogger
virtual void setDebugLogger()
Create and set a debug logger to the FMTObject.

Core::FMTObject::forceLoad
void forceLoad(Archive &ar, const unsigned int version)
Force the serialization to load useful information, which the default FMTObject serialization does no...
Definition: FMTObject.h:238

Core::FMTObject::_logger
static std::unique_ptr< Logging::FMTLogger > _logger
A shared pointer to the logger.
Definition: FMTObject.h:215

Core::FMTObject::passInExceptionHandler
void passInExceptionHandler(const std::unique_ptr< Exception::FMTExceptionHandler > &exhandler)
Pass in the exception handler of another FMTObject.

Core::FMTObject::setCplHandler
void setCplHandler()
Pass the FMT exception handler to the GDAL exception handler (GDAL only).

Core::FMTObject::_exhandler
static std::unique_ptr< Exception::FMTExceptionHandler > _exhandler
A shared pointer to the exception handler.
Definition: FMTObject.h:212

Core::FMTObject::setFreeExceptionHandler
void setFreeExceptionHandler()
Create and set a free exception handler to the FMTObject.

Core::FMTObject::enableNestedExceptions
void enableNestedExceptions()
Enable the nested exception throw of the exception handler.

Core::FMTObject::FMTObject
FMTObject()
Default constructor for FMTObject.

Core::FMTObject::setDefaultLogger
virtual void setDefaultLogger()
Create and set a default logger to the FMTObject.

Core::FMTObject::redirectLogToFile
void redirectLogToFile(const std::string &location)
Redirect the log to a specific file, appending to it.

Core::FMTObject::getClock
static std::chrono::time_point< std::chrono::high_resolution_clock > getClock()
Return a clock of the current time.

Core::FMTObject::setTaskLogger
virtual void setTaskLogger()
Create and set a task logger to the FMTObject.

Core::FMTObject::FMTObject
FMTObject(const FMTObject &rhs)
Copy constructor for FMTObject.

Core::FMTObject::checkSignals
void checkSignals() const
Check if the user has sent a ctrl-c signal using boost::python to FMT.

Core::FMTObject::getRuntimeLocation
static std::string getRuntimeLocation()
Return the location of the FMT shared library.

Core::FMTObject::getDuration
static double getDuration(const std::chrono::time_point< std::chrono::high_resolution_clock > &startclock)
Return the time elapsed since a start clock as a double.

Core::FMTObject::getAvailableMemory
static unsigned long long getAvailableMemory()
Return the available memory in bytes.

Core::FMTObject::FMTObject
FMTObject(const std::unique_ptr< Exception::FMTExceptionHandler > exhandler)
Construct a FMTObject passing in the exception handler of another FMTObject.

Core::FMTObject::setDefaultExceptionHandler
void setDefaultExceptionHandler()
Create and set a default exception handler to the FMTObject.

Core::FMTObject::_terminate
static void _terminate()
Raise an error with the boost stacktrace.

Core::FMTObject::~FMTObject
virtual ~FMTObject()
Default virtual destructor for FMTObject.

Core::FMTObject::serialize
void serialize(Archive &ar, const unsigned int version)
Definition: FMTObject.h:203

Core::FMTObject::_logStack
static void _logStack()
Log the stack trace...

Core::FMTObject::setAbortStack
static void setAbortStack()
will write the stack in the log when abort called with SIGABRT and raise a function failed.

Core::FMTObject::setErrorsToWarnings
void setErrorsToWarnings(const std::vector< Exception::FMTexc > &errors)
Set a list of errors to be cast to warnings on the exception handler.

Core::FMTObject::_abort
static void _abort(int p_signal)
Raise an error with the boost stacktrace on abort.

Core::FMTObject::setQuietLogger
virtual void setQuietLogger()
Create and set a quiet logger to the FMTObject.

Core::FMTObject::disableNestedExceptions
void disableNestedExceptions()
Disable the nested exception throw of the exception handler.

Core::FMTObject::passInLogger
virtual void passInLogger(const std::unique_ptr< Logging::FMTLogger > &logger)
Pass in the logger of another FMTObject.

Core::FMTObject::setTerminateStack
static void setTerminateStack()
will write the stack in the log when terminate called and raise a function failed.

Core::FMTObject::setMaxWarningsBeforeSilenced
void setMaxWarningsBeforeSilenced(const size_t &maxwarningcount)
Set the number of warnings raised before being silenced.

Core::FMTObject::setDebugExceptionHandler
void setDebugExceptionHandler()
Create and set a debug exception handler to the FMTObject.

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

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

Core
The Core namespace provides classes for simulating stands/strata growth/harvest through time.
Definition: FMTAction.h:34

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

Logging
Namespace for the log management, provides different log handlers.
Definition: FMTDebugLogger.h:14