exception.hh

Go to the documentation of this file.

#ifndef _DRAMA2_EXCEPT_H
#define _DRAMA2_EXCEPT_H
 
/*
 * History:
     08-Jan-2014 - TJF - Original version.
     30-Sep-2016 - TJF - There were many changes before now.
                          Fix some formatting in Print() and ErsRep().           
     20-Jan-2019 - TJF - Resolve with with the results of what() being 
                        rubbish.  This required I added the _whatString
                        item and update it each time the value of toString
                        would be changed.  This is likely due to what in
                        effect return a c_str() result from a temp.
     25-May-2021 - TJF - Have now created exception.cpp and the implementation
                           of all methods with and complexity which are not
                           templates or others required as inline have been
                           moved to it.
 
 */
 
#include "drama.h"
#include "status.h"
#include "mess.h"
#include "drama2_err.h"
#include <string>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <execinfo.h>  // For backtrace and backtrace_symbols
#include <sstream>  // For ostringstream
#include <cxxabi.h>
#include <iostream>
#include "Ers.h"
#include <iomanip>      // To allow std::hex() to be used.
#include <vector>
#include "drama/util.hh"
 
 
#define DramaTHROW(status_,message_) throw drama::Exception(__func__, __FILE__,__LINE__,(message_), (status_)) 
 
// From C++20, we could use std::source_location instead of
//  the macros for these calls.  But we want to support back to C++11 
//  at this time.
 
 
 
#define DramaTHROW_S(status_,format_,...) drama::ExceptionThrowSafe(__func__, __FILE__,__LINE__,(status_), (format_), __VA_ARGS__)
 
 
 
namespace drama
{
    class Exception : public std::exception {
 
    private :
        // Note  line and  file are not currently used
        // through the values are set correctly.  It may be appropriate
        // for methods to be added to access them later.
        int _lineNum;                // Line number exception was thrown from
        std::string _sourceFile;     // Source file exception was thrown from
        std::string _sourceFunc;     // Function exception was thrown from.
        std::string _origMessage;    // Original contextual message
        StatusType _dramaStatus;     // DRAMA Error code.
        std::ostringstream _message; // Message to be output.
        std::ostringstream _stackTrace; // Stack trace recorded here.
        static const unsigned _stackTraceMax = 25; // Max elements in stack trace.
        std::string _whatString; //Used for result of what() to avoid temp going out of scope.
 
        static bool _firstReportDone;  // We report about the environment variable
                                      // that causes more details to be output
                                      // on the first report only.
        bool _alwaysStacktrace = false; // Does we always output the stack trace.
        /*
         * Generate the stack track.  
         *
         *  array size is _stackTraceMax, and has been field out 
         *  by a call to backtrace().  nSize elements are valid.
         */
        void GenerateStackTrace(const int nSize, void *array[]);
        /*
         * Support method for GenerateStackTrace.
         */
        void AddStackTraceLine(char *stackString);
 
    public:
        Exception() : _lineNum(0), _sourceFile("none"),
                _sourceFunc("none"), _origMessage("none"), 
                _dramaStatus(STATUS__OK) { }
 
 
        Exception(const std::string func,
                  const std::string &file,
                  const int lineNum,
                  const std::string &message = "",
                  const StatusType status=DRAMA2__CPP_ERROR,
                  const bool alwaysStacktrace = false);
 
        
        D2DEPRECATED Exception(
            bool makeUnique DUNUSED,
            const std::string func,    // Set to __func__
            const std::string &file,   // Set to __FILE__
            const int lineNum,         // Set to __LINE__
            const StatusType status,
            const char *format, ...) : 
            Exception(func, file, lineNum, "<<C-Format>", status) 
            {
                va_list ap;
                va_start(ap, format);
                char buffer[200];
                vsnprintf(buffer, sizeof(buffer), format, ap);
                _message.str("");  // Clear result of primary constructor.
                _origMessage = buffer;
                _message << buffer; // Add the real message required.
                _whatString = toString();
            }  
 
        // Needed as _message can't be copied directly. 
        Exception(const Exception &source) : 
            _lineNum(source._lineNum), 
            _sourceFile(source._sourceFile), 
            _sourceFunc(source._sourceFunc), 
            _origMessage(source._origMessage), 
            _dramaStatus(source._dramaStatus),
            _whatString(source._whatString),
            _alwaysStacktrace(source._alwaysStacktrace) {
            _message.str(source._message.str());
        }
 
        Exception(Exception &&source) noexcept : 
            _lineNum(std::move(source._lineNum)), 
            _sourceFile(std::move(source._sourceFile)), 
            _sourceFunc(std::move(source._sourceFunc)), 
            _origMessage(std::move(source._origMessage)), 
            _dramaStatus(std::move(source._dramaStatus)),
            _whatString(std::move(source._whatString)),
            _alwaysStacktrace(source._alwaysStacktrace) {
 
            // I thought I should have been able to initialize _message above()
            // using _message(std::move(source._message)) as streams are
            // are supposed to support move, but this didn't work when tried
            // with GCC 4.7.  So we still use this expensive operation.
                
            _message.str(source._message.str());
            _stackTrace.str(source._stackTrace.str());
        }
      
        // Needed as _message can't be copied directly.
        Exception& operator=(const Exception &rhs) {
 
            if (this == &rhs)
                return *this;
 
            this->_sourceFile  = rhs._sourceFile;
            this->_sourceFunc  = rhs._sourceFunc;
            this->_lineNum     = rhs._lineNum;
            this->_origMessage = rhs._origMessage;
            this->_dramaStatus = rhs._dramaStatus;
            this->_whatString  = rhs._whatString;
 
            this->_message.str(rhs._message.str()); // Copy in message string.
            this->_stackTrace.str(rhs._stackTrace.str());
            this->_alwaysStacktrace = rhs._alwaysStacktrace;
            return *this;
        }
        Exception& operator=(Exception &&rhs) noexcept {
 
            if (this == &rhs)
                return *this;
 
            this->_sourceFile  = std::move(rhs._sourceFile);
            this->_sourceFunc  = std::move(rhs._sourceFunc);
            this->_lineNum     = std::move(rhs._lineNum);
            this->_origMessage = std::move(rhs._origMessage);
            this->_dramaStatus = std::move(rhs._dramaStatus);
            this->_whatString  = std::move(rhs._whatString);
 
            // I Think Should be possible, but didn't work in GCC 4.7.1, 4.8.2 
            // this->_message = std::move(rhs._message);
 
            this->_message.str(rhs._message.str()); // Copy in message string.
            this->_stackTrace.str(rhs._stackTrace.str());
 
            this->_alwaysStacktrace = rhs._alwaysStacktrace;
 
            return *this;
        }
 
 
 
 
        virtual std::string toString(bool details=false) const;
 
        virtual const std::string & getOrigMessage() const {
            return _origMessage;
        }
        virtual int lineNumber() const {
            return _lineNum;
        }
        virtual const std::string & fileName() const {
            return _sourceFile;
        }
        virtual const std::string & function() const {
            return _sourceFunc;
        }
        virtual StatusType dramaStatus() const {
            return _dramaStatus;
        }
        virtual std::string dramaStatusStr() const;
 
        virtual int statusAsSysExitCode() const {
            return MessStatusToSysExit(_dramaStatus);
        }
 
        void AddErs();
 
 
        template<class T> 
        Exception & operator << (const T &t)  {
            _message << t;
            //_message << std::endl << t;
            _whatString = toString(); // Ensure what string updated.
            return *this;
        }
 
        virtual std::string getStackTrace() const  {
            return _stackTrace.str();
        }
 
        virtual void Print(FILE *file=stderr, bool include_stacktrace=false) const;
 
        virtual void ErsRep() const;
 
 
        virtual void ErsOut() const;
 
        const char* what() const noexcept override {
            return _whatString.c_str();
        }
 
 
        void FmtWrite(const char *str);
 
        template<typename T, typename... Types>
        void FmtWrite(const char * format,
                      T value,
                      Types... args) {
            while (*format) 
            {
                if (*format == '%') 
                {
                    if (*(format + 1) == '%') 
                    {
                        ++format;
                    }
                    else 
                    {
                        *this << value;
                        FmtWrite(format + 1, args...); // call even when *s == 0 to detect extra arguments
                        return;
                    }
                }
                *this << *format++;
             }
            DramaTHROW(DRAMA2__INV_EXCEPTION_CALL,
                           "extra arguments provided to drama::ExceptionThrowSafe");
        }
 
        virtual ~Exception() {};
 
    }; // Class Exception
 
 
 
    template<typename... Types>
    void ExceptionThrowSafe[[ noreturn ]] (const std::string func,
                            const std::string &file,
                            const int lineNum,
                            StatusType status, 
                            const char * format,
                                 Types... args) 
    {
        drama::Exception e(func, file, lineNum, "", status);
 
        e.FmtWrite(format, args...);
 
        throw e;
    
    }
 
 
 
 
} // namespace drama
 
 
 
 
inline std::ostream& operator << (std::ostream &strm, const drama::Exception & e)
{
    strm << e.toString(true);
    return strm;
}
 
 
#endif /* _DRAMA2_EXCEPT_H */