Classes/C_Exceptions.h - AddMacOS - Dengit-man/CustomLocaleKeyShortcut

Classes/C_Exceptions.h
248 строк9 KB
Dengit-man
Фикс мелочей - 1.5.1
27 май 2026, 14:23
27 май 2026, 14:2328ae8d3
//
// Created by Dengit-man on 08.02.2025.
// Правообладатель (c) 2026 Пользователь GitVerse "Dengit-man"
//

#ifndef C_EXCEPTIONS_H
#define C_EXCEPTIONS_H

#include <cassert>
#include <cstring>
#include <exception>
#include <format>
#include "C_Logger.h"

#if defined(__MINGW32) || defined(__MINGW64__)
#define ___NODISCARD
#else
#define ___NODISCARD _NODISCARD
#endif

#define CREATE_EXCEPTION(EName) class EName : public C_Exception        \
{                                                                       \
protected:                                                              \
    std::string F_Name = #EName;                                         \
    virtual std::string GetName() const override                         \
    {                                                                   \
        LogDebug(std::format("Started [{0}]", this->F_Name), false);            \
        return this->F_Name;                                             \
    }                                                                   \
public:                                                                 \
    explicit EName(char const* const _Message)                          \
        : C_Exception(_Message)                                         \
    {                                                                   \
        LogDebug(std::format("Started [{0}]", _Message), false);               \
    }                                                                   \
    EName(char const* const _Message, int  /*unused*/)                  \
        : C_Exception(_Message,0)                                       \
    {                                                                   \
        LogDebug(std::format("Started [{0}]", _Message), false);               \
    }                                                                   \
    explicit EName(const std::string &_Message) noexcept                \
        : C_Exception(_Message.c_str(),0)                               \
    {                                                                   \
        LogDebug(std::format("Started [{0}]", _Message), false);               \
    }                                                                   \
    void raise() const override { throw *this; }                        \
    EName *clone() const override { return new EName(*this); }          \
};

class C_Exception : public std::exception
{
private:
    std::string FName = "C_Exception";
protected:
    std::string FMsg;
    virtual std::string GetName() const
    {
        LogDebug(std::format("Started [{0}]", this->FName), false);
        return this->FName;
    }
public:

    C_Exception() noexcept
            : std::exception()
    {
        LogDebug(std::string("Started"), false);
    }

    explicit C_Exception(char const* const Message) noexcept
            : FMsg(Message)
    {
        LogDebug(std::format("Started [{0}]", Message), false);
    }

    C_Exception(char const* const Message, int /*unused*/) noexcept
            : FMsg(Message)
    {
        LogDebug(std::format("Started [{0}]", Message), false);
    }
    explicit C_Exception(const std::string &Message) noexcept
            : FMsg(Message)
    {
        LogDebug(std::format("Started [{0}]", Message), false);
    }


#ifdef __APPLE__
    [[nodiscard]] const char* what() const _NOEXCEPT override
    {
        //TODO Проверить результат strcpy_s на наличие ошибок
        char const* unkn = "Unknown exception";
        char *tmpd = nullptr;
        char* Result_of_strcpy_s = 0;
        size_t size = 0;
        if(this->FMsg.empty())
        {
            size = strlen(unkn);
            tmpd = new char[size + 1]; //TODO 4: проанализировать необходимость обработки потенциального исключения
            Result_of_strcpy_s = strncpy(tmpd, unkn, sizeof(char)*size);
        }
        else
        {
            size = this->FName.length();
            tmpd = new char[size + 1]; //TODO 4: проанализировать необходимость обработки потенциального исключения
            Result_of_strcpy_s = strncpy(tmpd, this->FName.c_str(), sizeof(char)*size);
        }
        assert(Result_of_strcpy_s == tmpd);

        return tmpd;
    }
#else
    ___NODISCARD
#if defined(__MINGW32__) || defined(__MINGW64__)
    [[nodiscard]] const char* what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT override
#else
    [[nodiscard]] char const*  what() const override
#endif
    {
        //TODO 5: Проверить результат strcpy_s на наличие ошибок
        char *tmpd = nullptr;
        int Result_of_strcpy_s = 0;
        size_t size = 0;
        if(this->FMsg.empty())
        {
            char const* unkn = "Unknown exception";
            size = strlen(unkn);
            tmpd = new char[size + 1]; //TODO 4: проанализировать необходимость обработки потенциального исключения
            Result_of_strcpy_s = strcpy_s(tmpd, sizeof(char)*size, unkn);
        }
        else
        {
            size = this->FName.length();
            tmpd = new char[size + 1]; //TODO 4: проанализировать необходимость обработки потенциального исключения
            Result_of_strcpy_s = strcpy_s(tmpd, sizeof(char)*size, this->FName.c_str());
        }
        assert(Result_of_strcpy_s == 0);

        return tmpd;
    }
#endif

#ifdef __APPLE__
    [[nodiscard]] const char*  m_name() const
    {
        //TODO Проверить результат strcpy_s на наличие ошибок
        char const* unkn = "C_Exception";
        char *tmpd = nullptr;
        char* Result_of_strcpy_s = 0;
        size_t size = 0;
        if(this->FMsg.empty())
        {
            size = strlen(unkn);
            tmpd = new char[size + 1]; //TODO 4: проанализировать необходимость обработки потенциального исключения
            Result_of_strcpy_s = strncpy(tmpd, unkn, sizeof(char)*size);
        }
        else
        {
            size = this->FName.length();
            tmpd = new char[size + 1]; //TODO 4: проанализировать необходимость обработки потенциального исключения
            Result_of_strcpy_s = strncpy(tmpd, this->FName.c_str(), sizeof(char)*size);
        }
        assert(Result_of_strcpy_s == tmpd);

        return tmpd;
    }
#else
    ___NODISCARD
#if defined(__MINGW32__) || defined(__MINGW64__)
    [[nodiscard]] const char*
    m_name() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT
#else
    [[nodiscard]] char const*  m_name() const
#endif
    {
        //TODO Проверить результат strcpy_s на наличие ошибок
        char const* unkn = "C_Exception";
        char *tmpd = nullptr;
        int Result_of_strcpy_s = 0;
        size_t size = 0;
        if(this->FName.empty())
        {
            size = strlen(unkn);
            tmpd = new char[size + 1]; //TODO 4: проанализировать необходимость обработки потенциального исключения
            Result_of_strcpy_s = strcpy_s(tmpd, sizeof(char)*size, unkn);
        }
        else
        {
            size = this->FName.length();
            tmpd = new char[size + 1]; //TODO 4: проанализировать необходимость обработки потенциального исключения
            Result_of_strcpy_s = strcpy_s(tmpd, sizeof(char)*size, this->FName.c_str());
        }
        assert(Result_of_strcpy_s == 0);

        return tmpd;
    }
#endif

    std::string name() const
    {
        return this->GetName();
    }
    std::string message() const
    {
        return this->FMsg;
    }
    /* std::string m_name() const
    {
        //TODO Проверить результат strcpy_s на наличие ошибок
        char const* unkn = "C_Exception";
        char *tmpd = nullptr;
        int Result_of_strcpy_s = 0;
        if(this->FName.empty())
        {
            tmpd = new char(strlen(unkn) + 1);
            Result_of_strcpy_s = strcpy_s(tmpd, sizeof(char), unkn);
        }
        else
        {
            tmpd = new char(this->FName.length()+1);
            Result_of_strcpy_s = strcpy_s(tmpd, sizeof(char), this->FName.c_str());
        }
        assert(Result_of_strcpy_s != 0);

        return tmpd;
    }*/

    virtual void raise() const //override
    {
        throw *this;
    }
    [[nodiscard]] virtual C_Exception *clone() const //override
    {
        return new C_Exception(*this);
    }
};

CREATE_EXCEPTION(EObjectIsNULL);
CREATE_EXCEPTION(EObjectIsNotInitialized);
CREATE_EXCEPTION(EObjectIsAlreadyInitialized);
CREATE_EXCEPTION(EInvalidString);
CREATE_EXCEPTION(EInvalidValue);
CREATE_EXCEPTION(ENotImplemented);
CREATE_EXCEPTION(ENotANumber);
CREATE_EXCEPTION(EDeprecated);
CREATE_EXCEPTION(EInvalidObjectState);
CREATE_EXCEPTION(EFatalException);

#endif //C_EXCEPTIONS_H