Exceptions.hpp

//---- GPL ---------------------------------------------------------------------
//
// Copyright (C)  Stichting Deltares, 2011-2023.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation version 3.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// contact: delft3d.support@deltares.nl
// Stichting Deltares
// P.O. Box 177
// 2600 MH Delft, The Netherlands
//
// All indications and logos of, and references to, "Delft3D" and "Deltares"
// are registered trademarks of Stichting Deltares, and remain the property of
// Stichting Deltares. All rights reserved.
//
//------------------------------------------------------------------------------
 
#pragma once
 
#include "MeshKernel/Constants.hpp"
#include "MeshKernel/Definitions.hpp"
#include "MeshKernel/Formatting.hpp"
 
#include <algorithm>
#include <exception>
#include <source_location>
#include <sstream>
#include <stdexcept>
#include <string>
#include <string_view>
 
#define STRINGIFY(str) #str
#define TO_STR_LITERAL(str) STRINGIFY(str)
 
namespace meshkernel
{
 
    // Note: Do not change the values. This has an impact on the front-end.
    //       To add a new code, append and set to the highest existing value incremented by 1.
    enum ExitCode
    {
        Success = 0,                 
        MeshKernelErrorCode = 1,     
        NotImplementedErrorCode = 2, 
        AlgorithmErrorCode = 3,      
        ConstraintErrorCode = 4,     
        MeshGeometryErrorCode = 5,   
        LinearAlgebraErrorCode = 6,  
        RangeErrorCode = 7,          
        StdLibExceptionCode = 8,     
        UnknownExceptionCode = 9     
    };
    enum ExitCode {…};
 
    class ErrorCategory
    {
    public:
        ErrorCategory(std::string_view name,
                      ExitCode exit_code)
            : m_name(name),
              m_exit_code{exit_code}
        {
        }
        ErrorCategory(std::string_view name, {…}
 
        [[nodiscard]] std::string_view Name() const { return m_name; }
 
        [[nodiscard]] ExitCode Code() const { return m_exit_code; }
 
    private:
        std::string_view m_name; 
        ExitCode m_exit_code;    
    };
    class ErrorCategory {…};
 
    class FormatString final
    {
    public:
        FormatString(const char* const format_string,
                     std::source_location const& source_location = std::source_location::current())
            : m_format_string(format_string),
              m_source_location(source_location)
        {
        }
        FormatString(const char* const format_string, {…}
 
        FormatString(std::string_view message,
                     std::source_location const& source_location = std::source_location::current())
            : m_format_string(message),
              m_source_location(source_location)
        {
        }
        FormatString(std::string_view message, {…}
 
        FormatString(std::string const& message,
                     std::source_location const& source_location = std::source_location::current())
            : m_format_string(message),
              m_source_location(source_location)
        {
        }
        FormatString(std::string const& message, {…}
 
        [[nodiscard]] std::string_view String() const { return m_format_string; }
 
        [[nodiscard]] std::source_location const& SourceLocation() const { return m_source_location; }
 
    private:
        std::string_view m_format_string; 
 
        std::source_location m_source_location; 
    };
    class FormatString final {…};
 
    class MeshKernelError : public std::exception
    {
    public:
        template <typename... Args>
        MeshKernelError(FormatString const& format_string, Args&&... args)
            : m_what(),
              m_source_location(format_string.SourceLocation())
        {
            if (sizeof...(args) == 0)
            {
                m_formatted_message = format_string.String();
            }
            else
            {
                m_formatted_message = fmt_ns::vformat(format_string.String(), fmt_ns::make_format_args(args...));
            }
        }
        MeshKernelError(FormatString const& format_string, Args&&... args) {…}
 
        virtual ~MeshKernelError() = default;
 
        const char* what() const noexcept override
        {
#if HAVE_SRC_LOC_IN_ERR_MSGS
            m_what = fmt_ns::format("Exception of type '{}' in {} ({}:{}) {}: {}\n",
                                    Category().Name(),
                                    StrippedFilePath(),
                                    m_source_location.line(),
                                    m_source_location.column(),
                                    m_source_location.function_name(),
                                    FormattedMessage());
#else
            m_what = fmt_ns::format("Exception of type '{}': {}\n",
                                    Category().Name(),
                                    FormattedMessage());
#endif
            return m_what.c_str();
        }
        const char* what() const noexcept override {…}
 
        [[nodiscard]] ExitCode Code() const { return Category().Code(); }
 
    protected:
        [[nodiscard]] virtual ErrorCategory Category() const
        {
            return {"MeshKernelError", ExitCode::MeshKernelErrorCode};
        }
        [[nodiscard]] virtual ErrorCategory Category() const {…}
 
        [[nodiscard]] virtual std::string FormattedMessage() const { return m_formatted_message; }
 
    private:
        std::string m_formatted_message; 
 
        mutable std::string m_what; 
 
        std::source_location m_source_location; 
 
        [[nodiscard]] std::string StrippedFilePath() const
        {
            std::string path = m_source_location.file_name();
#ifdef CMAKE_SRC_DIR
            std::string path_to_erase(TO_STR_LITERAL(CMAKE_SRC_DIR));
#ifdef _WIN32
            std::replace(path_to_erase.begin(), path_to_erase.end(), '/', '\\');
#endif
            if (size_t pos = path.find(path_to_erase); pos != std::string::npos)
            {
                // erase including the trailing slash
                path.erase(pos, path_to_erase.length() + 1);
#ifdef _WIN32
                std::replace(path.begin(), path.end(), '\\', '/');
#endif
            }
#endif
            return path;
        }
    };
    class MeshKernelError : public std::exception {…};
 
    class NotImplementedError final : public MeshKernelError
    {
    public:
        using MeshKernelError::MeshKernelError;
 
    private:
        [[nodiscard]] ErrorCategory Category() const override
        {
            return {"NotImplementedError", ExitCode::NotImplementedErrorCode};
        }
    };
    class NotImplementedError final : public MeshKernelError {…};
 
    class AlgorithmError final : public MeshKernelError
    {
    public:
        using MeshKernelError::MeshKernelError;
 
    private:
        [[nodiscard]] ErrorCategory Category() const override
        {
            return {"AlgorithmError", ExitCode::AlgorithmErrorCode};
        }
    };
    class AlgorithmError final : public MeshKernelError {…};
 
    class ConstraintError final : public MeshKernelError
    {
    public:
        using MeshKernelError::MeshKernelError;
 
    private:
        [[nodiscard]] ErrorCategory Category() const override
        {
            return {"ConstraintError", ExitCode::ConstraintErrorCode};
        }
    };
    class ConstraintError final : public MeshKernelError {…};
 
    class MeshGeometryError final : public MeshKernelError
    {
    public:
        template <typename... Args>
        MeshGeometryError(meshkernel::UInt mesh_index,
                          Location mesh_location,
                          FormatString const& format_string,
                          Args&&... args)
            : MeshKernelError(format_string, std::forward<Args>(args)...),
              m_mesh_index(mesh_index),
              m_mesh_location(mesh_location)
        {
        }
        MeshGeometryError(meshkernel::UInt mesh_index, {…}
 
        [[nodiscard]] meshkernel::UInt MeshIndex() const { return m_mesh_index; }
 
        [[nodiscard]] Location MeshLocation() const { return m_mesh_location; }
 
    private:
        [[nodiscard]] ErrorCategory Category() const override
        {
            return {"MeshGeometryError", ExitCode::MeshGeometryErrorCode};
        }
 
        [[nodiscard]] std::string FormattedMessage() const override
        {
            return fmt_ns::format("Error occurred at index {} (location: {}). {}",
                                  m_mesh_index,
                                  LocationToString.at(m_mesh_location),
                                  MeshKernelError::FormattedMessage());
        }
 
        meshkernel::UInt m_mesh_index; 
        Location m_mesh_location;      
    };
    class MeshGeometryError final : public MeshKernelError {…};
 
    class LinearAlgebraError final : public MeshKernelError
    {
    public:
        using MeshKernelError::MeshKernelError;
 
    private:
        [[nodiscard]] ErrorCategory Category() const override
        {
            return {"LinearAlgebraError", ExitCode::LinearAlgebraErrorCode};
        }
    };
    class LinearAlgebraError final : public MeshKernelError {…};
 
    class RangeError final : public MeshKernelError
    {
    public:
        using MeshKernelError::MeshKernelError;
 
    private:
        [[nodiscard]] ErrorCategory Category() const override
        {
            return {"RangeError", ExitCode::RangeErrorCode};
        }
    };
    class RangeError final : public MeshKernelError {…};
 
} // namespace meshkernel