CallbackError.h

Go to the documentation of this file.

 
#pragma once
#include <enrollment/Exception/EnrollmentException.h>
#include <enrollment/Exception/LicenseException.h>
#include <enrollment/Exception/NotSupportedException.h>
#include <enrollment/Exception/SourceLocation.h>
#include <enrollment/File/FileException.h>
#include <enrollment/Image/ImageException.h>
#include <enrollment/Serialization/Writer.h>
#include <optional>
#include <variant>
 
namespace inno
{
    /*
     * @ingroup g_Exception
     * @brief Type of error from binary implementation of enrollment-sdk
     */
    enum class CallbackErrorType : uint8_t
    {
        RUNTIME,
        INVALID_ARGUMENT,
        INVALID_ARGUMENT_BLANK_TEMPLATE,
        INVALID_ARGUMENT_UNSUPPORTED_TEMPLATE,
        INVALID_ARGUMENT_INCOMPATIBLE_TEMPLATE,
        INVALID_ARGUMENT_IMAGE,
        INVALID_ARGUMENT_NULL,
        LICENSE,
        LICENSE_NOT_FOUND,
        LICENSE_INVALID,
        LICENSE_EXPIRED,
        LICENSE_FEATURE_NOT_ALLOWED,
        LICENSE_INVALID_HWID,
        LICENSE_LIMIT_REACHED,
        NOT_SUPPORTED,
        FILE,
        IMAGE_DECODE,
        IMAGE_ENCODE,
        IMAGE_PROCESS,
        IMAGE_UNKNOWN
    };
 
    /*
     * @ingroup g_Exception
     * @brief Function pointer to save message and exception type.
     * @param type exception type
     * @param description error description
     * @param file location
     * @param line location
     * @param function location
     * @param object pointer to object that provides this call back
     * @note Only for C++
     */
    using ErrorCallback = void (*)(CallbackErrorType type,
                                   const char* description,
                                   const char* file,
                                   const char* function,
                                   int line,
                                   void* object);
 
    // See doc/Main.markdown "Header and Binary parts" for reason why we use pragma pack 1
#pragma pack(push, 1)
    /*
     * @ingroup g_Exception
     * @brief ErrorCallback's contains exception handle and function pointer as callback.
     * @note Only for C++
     */
    extern "C" struct ErrorCallbacks
    {
        // Exception handle. It is not used in binary. Binary provides this handle back to header part of library, that
        // cast it safely to already created Exception class.
        void* object;
        // Callback to store exception data
        ErrorCallback setException;
    };
#pragma pack(pop)
 
    /*
     * @ingroup g_Exception
     * @brief CallbackError is exception for binary part of libary due to @ref overview_design_hbp "C boundary".
     * It provides static functions that can be called from binary part to log messages.
     * @note Only for C++
     */
    class CallbackError
    {
    public:
        /*
         * @brief Get the CallbackError object
         *
         * @return ErrorCallbacks
         */
        [[nodiscard]] ErrorCallbacks GetCallbacks()
        {
            ErrorCallbacks cb = {};
            cb.object = this;
            cb.setException = &CallbackError::Set;
            return cb;
        }
 
        /*
         * @brief Set exception type and message for given CallbackError object
         *
         * @param type type of exception
         * @param description exception description
         * @param file location
         * @param line location
         * @param function location
         * @param object pointer to CallbackError object
         */
        static void Set(CallbackErrorType t,
                        const char* description,
                        const char* file,
                        const char* function,
                        int line,
                        void* object)
        {
            if (object == nullptr)
            {
                return;
            }
            static_cast<CallbackError*>(object)->Set(t, description, SourceLocation{ file, function, line });
        }
 
        /*
         * @brief Function will throw exception if set.
         * It reset error to be not thrown again in destructor.
         */
        void ThrowOnError()
        {
            if (exception.has_value())
            {
                std::visit([](auto e) { throw e; }, exception.value());
            }
        }
 
        /*
         * @brief Function sets stored error if any via given callbacks.
         */
        void PropagateVia(ErrorCallbacks& cb) const
        {
            if (exception.has_value() && cb.setException != nullptr)
            {
                std::visit(
                  [&](auto&& e)
                  {
                      cb.setException(type.value(),
                                      e.what(),
                                      e.Location().FileName().c_str(),
                                      e.Location().FunctionName().c_str(),
                                      e.Location().Line(),
                                      cb.object);
                  },
                  exception.value());
            }
        }
 
        CallbackError(CallbackErrorType t, std::string d, const SourceLocation& loc = SourceLocation{})
        {
            Set(t, std::move(d), loc);
        }
 
        /*
         * @return true when error occur
         */
        [[nodiscard]] bool IsError() const
        {
            return exception.has_value();
        }
 
        /*
         * @return error message
         */
        [[nodiscard]] const char* What() const noexcept
        {
            try
            {
                if (exception.has_value())
                {
                    return std::visit([](const auto& e) { return e.what(); }, exception.value());
                }
            }
            catch (...)
            {
                return "Failed to get CallbackError description";
            }
            return "";
        }
 
        /*
         * @return error type if any
         */
        [[nodiscard]] std::optional<CallbackErrorType> Type() const
        {
            return type;
        }
 
        CallbackError() = default;
 
    private:
        std::optional<std::variant<EnrollmentRuntimeException,
                                   EnrollmentInvalidArgumentException,
                                   LicenseException,
                                   LicenseNotFoundException,
                                   InvalidLicenseException,
                                   ExpiredLicenseException,
                                   LicenseFeatureNotAllowedException,
                                   InvalidHWIDException,
                                   LicenseLimitReachedException,
                                   NotSupportedException,
                                   InvalidTemplateException,
                                   UnsupportedTemplateException,
                                   FileException,
                                   ImageException,
                                   IncompatibleTemplateException,
                                   InvalidImageArgumentException,
                                   NullArgumentException>>
          exception;
        std::optional<CallbackErrorType> type;
 
        void Set(CallbackErrorType t, std::string d, const SourceLocation& loc)
        {
            type = t;
 
            switch (t)
            {
            case CallbackErrorType::RUNTIME:
                exception.emplace(EnrollmentRuntimeException(std::move(d), loc));
                return;
            case CallbackErrorType::INVALID_ARGUMENT:
                exception.emplace(EnrollmentInvalidArgumentException(std::move(d), loc));
                return;
            case CallbackErrorType::LICENSE:
                exception.emplace(LicenseException(std::move(d), loc));
                return;
            case CallbackErrorType::LICENSE_NOT_FOUND:
                exception.emplace(LicenseNotFoundException(std::move(d), loc));
                return;
            case CallbackErrorType::LICENSE_INVALID:
                exception.emplace(InvalidLicenseException(std::move(d), loc));
                return;
            case CallbackErrorType::LICENSE_EXPIRED:
                exception.emplace(ExpiredLicenseException(std::move(d), loc));
                return;
            case CallbackErrorType::LICENSE_FEATURE_NOT_ALLOWED:
                exception.emplace(LicenseFeatureNotAllowedException(std::move(d), loc));
                return;
            case CallbackErrorType::LICENSE_INVALID_HWID:
                exception.emplace(InvalidHWIDException(std::move(d), loc));
                return;
            case CallbackErrorType::LICENSE_LIMIT_REACHED:
                exception.emplace(LicenseLimitReachedException(std::move(d), loc));
                return;
            case CallbackErrorType::NOT_SUPPORTED:
                exception.emplace(NotSupportedException(std::move(d), loc));
                return;
            case CallbackErrorType::INVALID_ARGUMENT_BLANK_TEMPLATE:
                exception.emplace(InvalidTemplateException(std::move(d), loc));
                return;
            case CallbackErrorType::INVALID_ARGUMENT_UNSUPPORTED_TEMPLATE:
                exception.emplace(UnsupportedTemplateException(std::move(d), loc));
                return;
            case CallbackErrorType::FILE:
                exception.emplace(FileException(std::move(d), loc));
                return;
            case CallbackErrorType::IMAGE_DECODE:
                exception.emplace(ImageException(ImageException::Reason::DECODE_IMAGE, std::move(d), loc));
                return;
            case CallbackErrorType::IMAGE_ENCODE:
                exception.emplace(ImageException(ImageException::Reason::ENCODE_IMAGE, std::move(d), loc));
                return;
            case CallbackErrorType::IMAGE_PROCESS:
                exception.emplace(ImageException(ImageException::Reason::PROCESS_IMAGE, std::move(d), loc));
                return;
            case CallbackErrorType::IMAGE_UNKNOWN:
                exception.emplace(ImageException(ImageException::Reason::UNKNOWN_IMAGE, std::move(d), loc));
                return;
            case CallbackErrorType::INVALID_ARGUMENT_INCOMPATIBLE_TEMPLATE:
                exception.emplace(IncompatibleTemplateException(std::move(d), loc));
                return;
            case CallbackErrorType::INVALID_ARGUMENT_IMAGE:
                exception.emplace(InvalidImageArgumentException(std::move(d), loc));
                return;
            case CallbackErrorType::INVALID_ARGUMENT_NULL:
                exception.emplace(NullArgumentException(std::move(d), loc));
                return;
            }
 
            // When value is not in enum, return runtime
            std::string unknownMessage =
              "Unknown error type '" + std::to_string(static_cast<unsigned int>(t)) + "', " + d;
            exception = EnrollmentRuntimeException(std::move(unknownMessage), loc);
        }
    };
 
    /*
     * @ingroup g_Exception
     * @brief ThrowOnError class automatically throws exception when error occur in binary part of SDK
     * @note Only for C++
     */
    class ThrowOnError
    {
    public:
        // Allow implicit conversion to ErrorCallbacks, enabling the use of ThrowOnError{} instead of explicitly calling
        // ThrowOnError{}.GetCallbacks(). NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
        operator ErrorCallbacks()
        {
            return error.GetCallbacks();
        }
        ThrowOnError() = default;
        ~ThrowOnError() noexcept(false)
        {
            error.ThrowOnError();
        }
        ThrowOnError(const ThrowOnError&) = delete;
        ThrowOnError(ThrowOnError&&) = delete;
        ThrowOnError& operator=(const ThrowOnError&) = delete;
        ThrowOnError& operator=(ThrowOnError&&) = delete;
 
    private:
        CallbackError error;
    };
 
    /*
     * @ingroup g_Exception
     * @brief It catches exception and transform them to callback calls
     * @param errorCallbacks callbacks to be used to propagate exception
     * @func function from which exceptions are caught and propagated
     * @loc source location of this function call
     * @note Only for C++
     */
    template<typename Func>
    auto ForwardExceptionToCallbacks(ErrorCallbacks errorCallbacks,
                                     Func&& func,
                                     const SourceLocation& loc = SourceLocation{}) -> decltype(func())
    {
        using ReturnType = decltype(func());
        try
        {
            if constexpr (std::is_void_v<ReturnType>)
            {
                std::forward<Func>(func)();
            }
            else
            {
                return std::forward<Func>(func)();
            }
        }
        catch (const EnrollmentException& e)
        {
            CallbackError{ CallbackErrorType::RUNTIME, e.what(), e.Location() }.PropagateVia(errorCallbacks);
        }
        catch (std::exception& e)
        {
            CallbackError{ CallbackErrorType::RUNTIME, e.what(), loc }.PropagateVia(errorCallbacks);
        }
        catch (...)
        {
            CallbackError{ CallbackErrorType::RUNTIME, "Unknown error", loc }.PropagateVia(errorCallbacks);
        }
 
        if constexpr (!std::is_void_v<ReturnType>)
        {
            return ReturnType{};
        }
    }
} // namespace inno