FluxioException.cpp

Go to the documentation of this file.

#include "FluxioException.h"
 
#include <ArmarXCore/core/logging/Logging.h>
 
namespace armarx::skills::error
{
    void
    FluxioException::addToContext(const std::optional<std::string>& contextItem,
                                  const std::optional<std::string>& className,
                                  const std::optional<std::string>& methodName,
                                  const std::optional<int>& line)
    {
        std::ostringstream oss;
        if (className.has_value() && methodName.has_value() && line.has_value())
        {
            oss << "From class " << className.value() << " in method " << methodName.value()
                << " in line " << line.value();
            if (contextItem.has_value())
            {
                oss << "\n" << contextItem.value();
            }
        }
        else if (contextItem.has_value())
        {
            oss << contextItem.value();
        }
        contextList.push_back(oss.str());
    }
 
    FluxioException
    FluxioException::create(const std::string& message,
                            const FluxioExceptionType& type,
                            const std::string& className,
                            const char* function,
                            int line)
    {
        FluxioException error(message, type);
        error.addToContext(std::nullopt, className, function, line);
        return error;
    }
 
    skills::manager::dto::FluxioException
    FluxioException::toManagerIce() const
    {
        skills::manager::dto::FluxioException ret;
        ret.message = message;
        ret.type = FluxioExceptionTypeToString(type);
        ret.contextList = contextList;
        return ret;
    }
 
    std::string
    FluxioException::FluxioExceptionTypeToString(const FluxioExceptionType& t)
    {
        switch (t)
        {
            case FluxioExceptionType::BAD_REQUEST:
                return "BAD_REQUEST";
            case FluxioExceptionType::FORBIDDEN:
                return "FORBIDDEN";
            case FluxioExceptionType::NOT_FOUND:
                return "NOT_FOUND";
            case FluxioExceptionType::UNAUTHORIZED:
                return "UNAUTHORIZED";
            default:
                ARMARX_WARNING << "Unknown error type: " << static_cast<int>(t);
                return "UNKNOWN";
        }
    }
} // namespace armarx::skills::error