builds/digitalwerk/solutions/adtf_content/adtf_base/adtf_core/src/libraries/a_utils/include/a_utils/core/result.h

Go to the documentation of this file.

 
#ifndef _A_UTILS_BASE_RESULT_H_
#define _A_UTILS_BASE_RESULT_H_
 
// #include <type_traits>
#include <a_utils/a_utils_version.h>
#include <a_utils/base/types.h>
#include <a_utils/base/error.h>
#include <a_utils/base/constants.h>
#include <a_utils/core/reference_counted_object_intf.h>
#include <a_utils/core/result_description.h>
#include <a_utils/core/error_description_intf.h>
 
#include <cstdio>
#include <cstdarg>
#ifdef _MSC_VER
    #include <sal.h>
#endif
#include <string>
#include <string_view>
#include <thread>
#include <sstream>
 
namespace A_UTILS_NS::detail
{
static inline std::string filename(std::string_view strPath)
{
    auto nLastSlash = strPath.rfind('/');
    if (nLastSlash == std::string::npos)
    {
        nLastSlash = strPath.rfind('\\');
    }
    if (nLastSlash == std::string_view::npos)
    {
        return std::string(strPath);
    }
    return std::string(strPath.substr(nLastSlash + 1));
}
 
static inline std::string filename_with_thread_id(std::string_view strPath)
{
    using namespace std::literals;
    std::ostringstream strBuffer;
    strBuffer << "tid="sv << std::this_thread::get_id() << " "sv << filename(strPath);
    return strBuffer.str();
}
 
static inline std::string
#ifdef __GNUC__
    __attribute__((format(printf, 1, 2)))
#endif // __GNUC__
    format(
#ifdef _MSC_VER
        _In_z_ _Printf_format_string_
#endif // _MSC_VER
        const char* strFormat,
        ...)
{
    va_list args, args_copy;
    va_start(args, strFormat);
    va_copy(args_copy, args);
    std::string strBuffer;
    strBuffer.resize(static_cast<size_t>(::std::vsnprintf(nullptr, 0, strFormat, args_copy)));
    va_end(args_copy);
    ::std::vsnprintf(strBuffer.data(), strBuffer.size() + 1, strFormat, args);
    va_end(args);
    return strBuffer;
}
} // namespace A_UTILS_NS::detail
 
#define IS_OK(s) ((s).IsOk())
 
#define IS_FAILED(s) ((s).IsFailed())
 
#define DETAILED_RESULT(_errcode, ...)                                           \
    tResult(_errcode, A_UTILS_NS::detail::format(__VA_ARGS__).c_str(), __LINE__, \
            A_UTILS_NS::detail::filename_with_thread_id(__FILE__).c_str(), __FUNC__)
#define RETURN_NOERROR return ERR_NOERROR
 
#if (__UCOM_ASSERT_WHEN_LOGGING_ERRORS == 1)
    #define RETURN_ERROR(_code) \
        assert(IS_OK(_code));   \
        return (_code)
    #define RETURN_ERROR_DESC(_code, ...) \
        assert(IS_OK(_code));             \
        return DETAILED_RESULT(_code, __VA_ARGS__)
#else
    #define RETURN_ERROR(code)            return (code)
    #define RETURN_ERROR_DESC(_code, ...) return DETAILED_RESULT(_code, __VA_ARGS__)
 
#endif
 
#define RETURN_IF_FAILED(s)      \
    {                            \
        tResult _errcode(s);     \
        if (_errcode.IsFailed()) \
        {                        \
            return (_errcode);   \
        }                        \
    }
 
#define RETURN_IF_FAILED_DESC(s, ...)                                           \
    {                                                                           \
        tResult _errcode(s);                                                    \
        if (_errcode.IsFailed())                                                \
        {                                                                       \
            return DETAILED_RESULT(_errcode.GetErrorCode().value, __VA_ARGS__); \
        }                                                                       \
    }
 
#define RETURN_IF_POINTER_NULL(_ptr) \
    if (nullptr == _ptr)             \
    {                                \
        RETURN_ERROR(ERR_POINTER);   \
    }
 
#define RETURN_IF_POINTER_NULL_DESC(_ptr, ...)            \
    if (nullptr == _ptr)                                  \
    {                                                     \
        return DETAILED_RESULT(ERR_POINTER, __VA_ARGS__); \
    }
 
namespace A_UTILS_NS
{
 
class cResult
{
public: // construction
    constexpr cResult() noexcept;
 
    constexpr cResult(decltype(ERR_NOERROR)) noexcept;
 
    template<tErrorCode::error_code_type ErrorCode>
    constexpr cResult(const tError<ErrorCode>& i_oError) noexcept;
 
    constexpr cResult(tErrorCode i_oError) noexcept;
 
    template<tErrorCode::error_code_type ErrorCode>
    explicit cResult(tError<ErrorCode> i_oError,
                     const tChar* i_strErrorDescription,
                     tInt32 i_nLine,
                     const tChar* i_strFile,
                     const tChar* i_strFunction) noexcept;
 
    constexpr explicit cResult(tErrorCode::error_code_type i_nErrorCode) noexcept;
 
    explicit cResult(tErrorCode::error_code_type i_nErrorCode,
                     const tChar* i_strErrorDescription,
                     tInt32 i_nLine,
                     const tChar* i_strFile,
                     const tChar* i_strFunction) noexcept;
 
    explicit cResult(const cResult& i_oResult,
                     const tChar* i_strErrorDescription,
                     tInt32 i_nLine,
                     const tChar* i_strFile,
                     const tChar* i_strFunction) noexcept;
 
    ~cResult() noexcept;
 
    cResult(const cResult& i_oOther) noexcept;
 
    cResult& operator=(decltype(ERR_NOERROR)) noexcept;
 
    cResult& operator=(cResult i_oOther) noexcept;
 
    constexpr cResult(cResult&& i_oOther) noexcept;
 
public: // access
    tErrorCode GetErrorCode() const noexcept;
 
    const tChar* GetErrorString() const noexcept;
 
    const tChar* GetDescription() const noexcept;
 
    tInt32 GetLine() const noexcept;
 
    const tChar* GetFile() const noexcept;
 
    const tChar* GetFunction() const noexcept;
 
    template<tErrorCode::error_code_type ErrorCode>
    tBool IsEqual(const tError<ErrorCode>& i_oErrorVal) const noexcept;
 
    template<typename... ErrorTypes>
    tBool IsEqual(const ErrorTypes&... i_oErrorVals) const noexcept;
 
    tBool IsOk() const noexcept;
 
    tBool IsFailed() const noexcept;
 
    friend void swap(cResult& i_oLHS, cResult& i_oRHS) noexcept;
 
    friend tBool operator==(const cResult& i_oLHS, const cResult& i_oRHS) noexcept;
 
private: // private constructor
    explicit cResult(tErrorCode i_nErrorCode,
                     const tChar* i_strErrorDescription,
                     tInt32 i_nLine,
                     const tChar* i_strFile,
                     const tChar* i_strFunction,
                     const tChar* i_strErrorCode) noexcept;
 
    static cResult CreateFrom(tErrorCode::error_code_type i_nErrorCode,
                              const tChar* i_strErrorDescription,
                              tInt32 i_nLine,
                              const tChar* i_strFile,
                              const tChar* i_strFunction) noexcept;
 
    static constexpr tErrorString GetErrorString(const tErrorCode& i_oErrorCode) noexcept;
 
private: // private member data
    typedef detail::result_description<detail::IErrorDescription> description_type; 
    description_type m_oResultHandler; 
 
private: // helper types
    template<typename ErrorType, typename... ErrorTypes>
    struct sErrorEval;
 
    template<typename ErrorType>
    struct sErrorEval<ErrorType>;
}; // class cResult
 
tBool operator!=(const cResult& i_oLHS, const cResult& i_oRHS) noexcept;
 
inline constexpr cResult::cResult() noexcept
{
}
 
inline constexpr cResult::cResult(decltype(ERR_NOERROR)) noexcept: cResult()
{
}
 
template<tErrorCode::error_code_type ErrorCode>
inline constexpr cResult::cResult(const tError<ErrorCode>& i_oError) noexcept:
    cResult(static_cast<tErrorCode>(i_oError))
{
}
 
inline constexpr cResult::cResult(tErrorCode i_oError) noexcept:
    m_oResultHandler(description_type::make_result_description(i_oError))
{
}
 
template<tErrorCode::error_code_type ErrorCode>
inline cResult::cResult(tError<ErrorCode> i_oError,
                        const tChar* i_strErrorDescription,
                        tInt32 i_nLine,
                        const tChar* i_strFile,
                        const tChar* i_strFunction) noexcept:
    cResult(static_cast<tErrorCode>(i_oError),
            i_strErrorDescription,
            i_nLine,
            i_strFile,
            i_strFunction,
            tError<ErrorCode>::str_error_code)
{
}
 
inline constexpr cResult::cResult(tErrorCode::error_code_type i_nErrorCode) noexcept: cResult(tErrorCode{i_nErrorCode})
{
}
 
inline cResult::cResult(tErrorCode::error_code_type i_nErrorCode,
                        const tChar* i_strErrorDescription,
                        tInt32 i_nLine,
                        const tChar* i_strFile,
                        const tChar* i_strFunction) noexcept:
    cResult(CreateFrom(i_nErrorCode, i_strErrorDescription, i_nLine, i_strFile, i_strFunction))
{
}
 
inline cResult::cResult(const cResult& i_oResult,
                        const tChar* i_strErrorDescription,
                        tInt32 i_nLine,
                        const tChar* i_strFile,
                        const tChar* i_strFunction) noexcept:
    cResult(
        i_oResult.GetErrorCode(), i_strErrorDescription, i_nLine, i_strFile, i_strFunction, i_oResult.GetErrorString())
{
}
 
inline cResult& cResult::operator=(cResult i_oOther) noexcept
{
    swap(*this, i_oOther);
    return *this;
}
 
inline cResult& cResult::operator=(decltype(ERR_NOERROR)) noexcept
{
    return cResult::operator=(cResult());
}
 
inline constexpr cResult::cResult(cResult&& i_oOther) noexcept: m_oResultHandler(std::move(i_oOther.m_oResultHandler))
{
}
 
inline tBool operator==(const cResult& i_oLHS, const cResult& i_oRHS) noexcept
{
    return i_oLHS.m_oResultHandler == i_oRHS.m_oResultHandler;
}
 
inline tBool operator!=(const cResult& i_oLHS, const cResult& i_oRHS) noexcept
{
    return !(i_oLHS == i_oRHS);
}
 
inline tBool cResult::IsOk() const noexcept
{
    return tErrorCode{} == GetErrorCode();
}
 
inline tBool cResult::IsFailed() const noexcept
{
    return !IsOk();
}
 
template<tErrorCode::error_code_type ErrorCode>
inline tBool cResult::IsEqual(const tError<ErrorCode>& i_oErrorVal) const noexcept
{
    return GetErrorCode() == static_cast<tErrorCode>(i_oErrorVal);
}
 
template<typename... ErrorTypes>
inline tBool cResult::IsEqual(const ErrorTypes&... i_oErrorVals) const noexcept
{
    return sErrorEval<ErrorTypes...>::dispatch(GetErrorCode(), i_oErrorVals...);
}
 
template<tErrorCode::error_code_type ErrorCode>
inline tBool operator==(const cResult& oResult, const tError<ErrorCode>& sCode) noexcept
{
    return oResult.IsEqual(sCode);
}
 
template<tErrorCode::error_code_type ErrorCode>
inline tBool operator!=(const cResult& oResult, const tError<ErrorCode>& sCode) noexcept
{
    return !oResult.IsEqual(sCode);
}
 
template<tErrorCode::error_code_type ErrorCode>
inline tBool operator==(const tError<ErrorCode>& sCode, const cResult& oResult) noexcept
{
    return oResult.IsEqual(sCode);
}
 
template<tErrorCode::error_code_type ErrorCode>
inline tBool operator!=(const tError<ErrorCode>& sCode, const cResult& oResult) noexcept
{
    return !oResult.IsEqual(sCode);
}
 
inline void swap(cResult& i_oLHS, cResult& i_oRHS) noexcept
{ // enable ADL
    using std::swap;
    swap(i_oLHS.m_oResultHandler, i_oRHS.m_oResultHandler);
}
 
template<typename ErrorType, typename... ErrorTypes>
struct cResult::sErrorEval
{
    static constexpr bool
        dispatch(tErrorCode i_oErrorCode, const ErrorType& i_oErrorVal, const ErrorTypes&... i_oErrorVals) noexcept
    {
        if (static_cast<tErrorCode>(i_oErrorVal) == i_oErrorCode)
        {
            return true;
        }
        else
        {
            return sErrorEval<ErrorTypes...>::dispatch(i_oErrorCode, i_oErrorVals...);
        }
    }
}; // template<typename ErrorType, typename ... ErrorTypes> struct sErrorEval
 
template<typename ErrorType>
struct cResult::sErrorEval<ErrorType>
{
    static constexpr bool dispatch(tErrorCode i_oErrorCode, const ErrorType& i_oErrorVal) noexcept
    {
        return static_cast<tErrorCode>(i_oErrorVal) == i_oErrorCode;
    }
}; // template<typename ErrorType> struct sErrorEval<ErrorType>
 
namespace detail
{
std::string to_string(const cResult& i_oResult);
}
 
} // namespace A_UTILS_NS
 
using tResult = A_UTILS_NS::cResult;
 
namespace std
{
template<>
inline void swap<A_UTILS_NS::cResult>(A_UTILS_NS::cResult& i_oLHS, A_UTILS_NS::cResult& i_oRHS) noexcept
{
    A_UTILS_NS::swap(i_oLHS, i_oRHS);
}
} // namespace std
 
#endif // _A_UTILS_BASE_RESULT_H_