repo/src/libraries/a_utils/include/a_utils/base/error.h

Go to the documentation of this file.

 
#ifndef A_UTILS_ERRORS_H
#define A_UTILS_ERRORS_H
 
#define IS_OK(s)                       ( ( s ).IsOk() )
 
#define IS_FAILED(s)                   ( ( s ).IsFailed() )
 
#define DETAILED_RESULT(_errcode, ...)                                                          \
    tResult(_errcode,                                                                           \
            A_UTILS_NS::cString::Format(__VA_ARGS__).GetPtr(),                                  \
            __LINE__,                                                                           \
            A_UTILS_NS::cFilename(__FILE__).GetName().GetPtr(),                                 \
            __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__); }
 
#define LOG_RESULT(code)        \
do\
{ \
    tResult _result = code; \
    if (IS_OK(_result))\
    {\
        LOG_INFO(A_UTILS_NS::to_string(_result));\
    } \
    else \
    {\
        LOG_ERROR(A_UTILS_NS::to_string(_result));\
    } \
} \
while(tFalse)
 
#define RETURN_AND_LOG_ERROR(code) \
do\
{ \
    tResult _result = code; \
    LOG_RESULT(_result); \
    return (_result); \
}\
while(tFalse)
 
#define RETURN_AND_LOG_ERROR_STR(code, ...) \
do\
{ \
    LOG_ERROR(__VA_ARGS__); \
    return (code); \
}\
while(tFalse)
 
#define RETURN_IF_FAILED_AND_LOG_ERROR_STR(code, ...) \
do\
{ \
    tResult _outer_result = code; \
    if (IS_FAILED(_outer_result)) \
    {\
        LOG_ERROR(__VA_ARGS__); \
        LOG_RESULT(_outer_result);\
        return _outer_result;\
    } \
}\
while(tFalse)
 
#ifdef _DEBUG
#define ASSERT_IF_POINTER_NULL(_ptr)    A_UTILS_ASSERT( nullptr != _ptr );
#else
#define ASSERT_IF_POINTER_NULL(_ptr)
#endif
 
#ifdef WIN32
    #define __FUNC__ __FUNCTION__
#else
    #define __FUNC__ __func__
#endif //WIN32
 
struct tErrorCode
{
    typedef tInt32 error_code_type; 
    error_code_type value;          
};//struct tErrorCode
 
struct tErrorString : public tErrorCode
{
    tErrorString() = default;
 
    tErrorString(const tErrorCode::error_code_type i_nErrorCode, const tChar* i_strErrorCode) :
        tErrorCode{ i_nErrorCode }, strValue(i_strErrorCode) {}
 
    const tChar* strErrorCode() const { return strValue; }
 
private:
    const tChar* const strValue;    
};//struct tErrorString
 
template<tErrorCode::error_code_type ReturnValue>
struct tError;
 
#define _MAKE_ERROR(_no, _strcode) /* (e.g. 2, ERR_UNKNOWN --> ERR_UNKNOWN = -2) */             \
    template< >                                                                                 \
    struct tError< -_no >                                                                       \
    {                                                                                           \
        explicit operator tErrorCode() const                                                    \
        {                                                                                       \
            return tErrorCode { -_no };                                                         \
        }                                                                                       \
        explicit operator tErrorString() const                                                  \
        {                                                                                       \
            return tErrorString { tError<-_no>::error_code, tError<-_no>::str_error_code };     \
        }                                                                                       \
        static constexpr const tChar* const str_error_code = #_strcode;                         \
        static constexpr const tErrorCode::error_code_type error_code = -_no;                   \
    };                                                                                          \
    static const tError<-_no> _strcode = tError<-_no>()
 
_MAKE_ERROR( 0, ERR_NOERROR          );
_MAKE_ERROR( 2, ERR_UNKNOWN          );
_MAKE_ERROR( 3, ERR_UNEXPECTED       );
_MAKE_ERROR( 4, ERR_POINTER          );
_MAKE_ERROR( 5, ERR_INVALID_ARG      );
_MAKE_ERROR( 6, ERR_INVALID_FUNCTION );
_MAKE_ERROR( 7, ERR_INVALID_ADDRESS  );
_MAKE_ERROR( 8, ERR_INVALID_HANDLE   );
_MAKE_ERROR( 9, ERR_INVALID_FLAGS    );
_MAKE_ERROR(10, ERR_INVALID_INDEX    );
_MAKE_ERROR(11, ERR_INVALID_FILE     );
_MAKE_ERROR(12, ERR_MEMORY           );
_MAKE_ERROR(13, ERR_TIMEOUT          );
_MAKE_ERROR(14, ERR_OUT_OF_SYNC      );
_MAKE_ERROR(15, ERR_RESOURCE_IN_USE  );
_MAKE_ERROR(16, ERR_NOT_IMPL         );
_MAKE_ERROR(17, ERR_NO_INTERFACE     );
_MAKE_ERROR(18, ERR_NO_CLASS         );
_MAKE_ERROR(19, ERR_NOT_SUPPORTED    );
_MAKE_ERROR(20, ERR_NOT_FOUND        );
_MAKE_ERROR(21, ERR_CANCELED         );
_MAKE_ERROR(22, ERR_RETRY            );
_MAKE_ERROR(23, ERR_FILE_NOT_FOUND   );
_MAKE_ERROR(24, ERR_PATH_NOT_FOUND   );
_MAKE_ERROR(25, ERR_ACCESS_DENIED    );
_MAKE_ERROR(26, ERR_NOT_READY        );
_MAKE_ERROR(27, ERR_OPEN_FAILED      );
_MAKE_ERROR(28, ERR_IO_INCOMPLETE    );
_MAKE_ERROR(29, ERR_IO_PENDING       );
_MAKE_ERROR(30, ERR_NOACCESS         );
_MAKE_ERROR(31, ERR_BAD_DEVICE       );
_MAKE_ERROR(32, ERR_DEVICE_IO        );
_MAKE_ERROR(33, ERR_DEVICE_NOT_READY );
_MAKE_ERROR(34, ERR_DEVICE_IN_USE    );
_MAKE_ERROR(35, ERR_NOT_CONNECTED    );
_MAKE_ERROR(36, ERR_UNKNOWN_FORMAT   );
_MAKE_ERROR(37, ERR_NOT_INITIALIZED  );
_MAKE_ERROR(38, ERR_FAILED           );
_MAKE_ERROR(39, ERR_END_OF_FILE      );
_MAKE_ERROR(40, ERR_INVALID_STATE    );
_MAKE_ERROR(41, ERR_EXCEPTION_RAISED );
_MAKE_ERROR(42, ERR_INVALID_TYPE     );
_MAKE_ERROR(43, ERR_EMPTY            );
_MAKE_ERROR(44, ERR_INVALID_VERSION  );
_MAKE_ERROR(45, ERR_INVALID_LICENSE  );
_MAKE_ERROR(46, ERR_SERVICE_NOT_FOUND);
_MAKE_ERROR(47, ERR_DAU              );
_MAKE_ERROR(48, ERR_IDLE_NOWAIT      );
_MAKE_ERROR(49, ERR_OUT_OF_RANGE     );
_MAKE_ERROR(50, ERR_KNOWN_PROBLEM    );
_MAKE_ERROR(51, ERR_INVALID_INTERFACE);
 
_MAKE_ERROR(52, ERR_INTERNAL         );
 
inline tBool operator== (const tErrorCode& lhs, const tErrorCode& rhs)
{
    return lhs.value == rhs.value;
}
 
inline tBool operator!= (const tErrorCode& lhs, const tErrorCode& rhs)
{
    return !operator==(lhs, rhs);
}
 
inline tBool operator< (const tErrorCode& lhs, const tErrorCode& rhs)
{
    return lhs.value < rhs.value;
}
 
inline tBool operator> (const tErrorCode& lhs, const tErrorCode& rhs)
{
    return operator<(rhs, lhs);
}
 
inline tBool operator<= (const tErrorCode& lhs, const tErrorCode& rhs)
{
    return !operator>(lhs, rhs);
}
 
inline tBool operator>= (const tErrorCode& lhs, const tErrorCode& rhs)
{
    return !operator<(lhs, rhs);
}
 
template<tErrorCode::error_code_type ErrorCodeLHS, tErrorCode::error_code_type ErrorCodeRHS>
inline tBool operator==(const tError<ErrorCodeLHS>& lhs, const tError<ErrorCodeRHS>& rhs)
{
    return static_cast<tErrorCode>(lhs) == static_cast<tErrorCode>(rhs);
}
 
template<tErrorCode::error_code_type ErrorCodeLHS, tErrorCode::error_code_type ErrorCodeRHS>
inline tBool operator!=(const tError<ErrorCodeLHS>& lhs, const tError<ErrorCodeRHS>& rhs)
{
    return !operator==(lhs, rhs);
}
 
template<tErrorCode::error_code_type ErrorCodeLHS, tErrorCode::error_code_type ErrorCodeRHS>
inline tBool operator<(const tError<ErrorCodeLHS>& lhs, const tError<ErrorCodeRHS>& rhs)
{
    return static_cast<tErrorCode>(lhs) < static_cast<tErrorCode>(rhs);
}
 
template<tErrorCode::error_code_type ErrorCodeLHS, tErrorCode::error_code_type ErrorCodeRHS>
inline tBool operator>(const tError<ErrorCodeLHS>& lhs, const tError<ErrorCodeRHS>& rhs)
{
    return operator<(rhs, lhs);
}
 
template<tErrorCode::error_code_type ErrorCodeLHS, tErrorCode::error_code_type ErrorCodeRHS>
inline tBool operator<=(const tError<ErrorCodeLHS>& lhs, const tError<ErrorCodeRHS>& rhs)
{
    return !operator>(lhs, rhs);
}
 
template<tErrorCode::error_code_type ErrorCodeLHS, tErrorCode::error_code_type ErrorCodeRHS>
inline tBool operator>=(const tError<ErrorCodeLHS>& lhs, const tError<ErrorCodeRHS>& rhs)
{
    return !operator<(lhs, rhs);
}
 
#endif //A_UTILS_ERRORS_H