CosmosError.hxx

#pragma once
 
// C++
#include <exception>
#include <string>
#include <string_view>
 
// cosmos
#include <cosmos/dso_export.h>
#include <cosmos/error/macros.hxx>
 
namespace cosmos {
 
/*
 * NOTE:
 *
 * It would be nice adding the possibility for a function call backtrace to
 * the exception class. There are a bunch of obstacles to this, though:
 *
 * There exists a kind of base mechanism present in Glibc and GCC/Clang:
 *
 * - using backtrace() and backtrace_symbols() from <execinfo.h>
 * - using abi::__cxa_demangle from <cxxabi.h>
 *
 * The limitations of this are:
 *
 * - no line number / source file information
 * - symbolic names are only available if all objects file are compiled with
 *   `-rexport` and -fvisibility=default. Even then static function names
 *   cannot be resolved.
 *
 * There exists libunwind: is it is readily available and offers symbolic
 * names even without changing the compilation and linking process. It does
 * not offer symbol demangling though which needs to come from cxxabi.h
 * instead. Also it comes with a file descriptor leak, because it creates a
 * pipe pair that is never cleaned up. Also it does not offer line number of
 * source file information.
 *
 * There are lesser known libraries like libbacktrace or backward-cpp, both of
 * them are rather big and not readily available, also not very actively
 * maintained (?).
 *
 * Further "hacks" to get additional debug information would be calling
 * external tools like `addr2line` or `gdb`.
 *
 * Another problem is that adding only the option to have a backtrace can
 * considerably increase the exception object size. A std::vector<std::string>
 * would add 24 bytes to the object size. A single std::string is similarly
 * sized. It could be heap-allocated which would reduce the overhead for
 * non-use to 8 bytes but then we have to manage the pointer e.g. when
 * copying, a shared_ptr would add 16 bytes of overhead.
 *
 * Overall to implement this feature maybe implementing parts of it on foot
 * using existing code snippets from libbacktrace & friends could be
 * investigated. Currently the problems seem not worth the gain.
 */
 
 
class COSMOS_API CosmosError :
                public std::exception {
public: // functions
 
        explicit CosmosError(const std::string_view error_class, const std::string_view fixed_text = {}) :
                        m_error_class{error_class} {
                m_msg = fixed_text;
        }
 
 
        CosmosError& setInfo(const char *file, const size_t line, const char *func) {
                m_line = line;
                m_file = file;
                m_func = func;
 
                return *this;
        }
 
 
        const char* what() const throw() override;
 
        std::string shortWhat() const;
 
        [[ noreturn ]] virtual void raise() = 0;
 
protected: // functions
 
 
        virtual void generateMsg() const {};
 
        void setErrorClass(const std::string_view error_class) {
                m_error_class = error_class;
        }
 
protected: // data
 
        std::string_view m_error_class;
        mutable std::string m_msg;
        mutable bool m_msg_generated = false;
        const char *m_file = nullptr;
        const char *m_func = nullptr;
        size_t m_line = 0;
};
 
} // end ns