HResult.h

Go to the documentation of this file.

//
 
#ifndef _INC_HResult_H
#define _INC_HResult_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "StrConst.h"
#include "cPair.h"
#include "FileName.h"           // FILECHAR_t
#include "cUnitTestDecl.h"
#ifdef _WIN32
#include <winerror.h>
#endif
 
namespace Gray
{
#if defined(_CPPUNWIND)
#define THROW_DEF throw()               // indicate that a function can throw exceptions.
#else
#define THROW_DEF __noop
#endif
 
#ifndef SUCCEEDED       // __linux__
#define SUCCEEDED(x)            (((HRESULT)(x)) >= S_OK)
#define FAILED(x)                       (((HRESULT)(x)) < S_OK)
#endif // __linux__
 
        extern GRAYCORE_LINK va_list k_va_list_empty;   // For faking out the va_list. __GNUC__ doesn't allow a pointer to va_list. So use this to simulate nullptr.
 
        enum FACILITY_TYPE
        {
 
#ifdef __linux__
                FACILITY_NULL = 0,              
                FACILITY_RPC = 1,               
                FACILITY_DISPATCH = 2,
                FACILITY_ITF = 4,               
                FACILITY_WIN32 = 7,             
                // FACILITY_DPLAY
#endif
                FACILITY_POSIX = 5,             
#ifdef __GNUC__
                FACILITY_SECURITY = 9,          
                FACILITY_INTERNET = 12,         
                FACILITY_COMPLUS = 17,
                FACILITY_HTTP = 25,             
                FACILITY_FVE = 49,              
#endif
                FACILITY_MMSYS = 0x100, 
                // FACILITY_DXAPP               = 0x200,        //!< Facility for DirectX sample application codes. Internal App codes.
                FACILITY_D3D = 0x876,   
        };
 
        enum HRESULT_WIN32_TYPE_
        {
#define HRESULT_WIN32_DEF(a,b,c)        a=b,
#include "HResultWin32.tbl"
#undef HRESULT_WIN32_DEF
        };
 
#if ! defined(LSTATUS) && ! defined(_WIN32)
        typedef LONG LSTATUS;   
#endif
#ifndef MAKE_HRESULT
#define MAKE_HRESULT(sev,fac,code)  ((HRESULT) (((unsigned long)(sev)<<31) | ((unsigned long)(fac)<<16) | ((unsigned long)(code))) )
#endif
#define HRESULT_WIN32_C(x)      MAKE_HRESULT(1,FACILITY_WIN32,(WORD)(x)) 
 
        enum HRESULT_OTHER_TYPE_
        {
 
#ifdef __linux__
                S_OK = ((HRESULT)0),
                S_FALSE = ((HRESULT)1),
 
                // Alias/Alternate names for existing FACILITY_WIN32 codes.
                E_ACCESSDENIED = HRESULT_WIN32_C(ERROR_ACCESS_DENIED),                  // "General access denied error"
                E_HANDLE = HRESULT_WIN32_C(ERROR_INVALID_HANDLE),               // "Invalid handle"
                E_OUTOFMEMORY = HRESULT_WIN32_C(ERROR_OUTOFMEMORY),                     // "Ran out of memory"
                E_INVALIDARG = HRESULT_WIN32_C(ERROR_INVALID_PARAMETER),                // "One or more arguments are invalid"
#endif
 
#define HRESULT_ENTRY(a,b,c,d) a=MAKE_HRESULT(1,b,c),   
#include "HResults.tbl"
#undef HRESULT_ENTRY
        };
 
        class GRAYCORE_LINK HResultCode
        {
        public:
                HRESULT m_hRes;                 
                const char* m_pszMsg;   
 
        public:
                int FindCode(HRESULT hRes) const;
        };
 
        class GRAYCORE_LINK HResult
        {
 
        public:
                typedef cPair<FACILITY_TYPE, const GChar_t*> Facility_t;        // name the facilities.
                static const Facility_t k_Facility[];   
 
                HRESULT m_hRes;
 
        public:
                HResult(HRESULT hRes) noexcept
                        : m_hRes(hRes)
                {
                }
                HResult(FACILITY_TYPE eFacility, WORD wCode) noexcept
                        : m_hRes(MAKE_HRESULT(1, eFacility, wCode))
                {
                }
                HResult(int eFacility, long wCode) noexcept
                        : m_hRes(MAKE_HRESULT(1, eFacility, wCode))
                {
                }
 
                operator HRESULT() const noexcept
                {
                        return m_hRes;
                }
 
                static inline DWORD GetCode(HRESULT hRes) noexcept
                {
                        return (DWORD)((hRes) & 0xFFFF);
                }
                inline DWORD get_Code() const noexcept
                {
                        return GetCode(m_hRes);
                }
 
                static inline FACILITY_TYPE GetFacility(HRESULT hRes) noexcept
                {
                        return (FACILITY_TYPE)(((hRes) >> 16) & 0x1fff);
                }
                inline FACILITY_TYPE get_Facility() const noexcept
                {
                        return GetFacility(m_hRes);
                }
 
                static inline bool IsFailure(HRESULT hRes) noexcept
                {
                        return hRes < 0;
                }
                bool isFailure() const noexcept
                {
                        return m_hRes < 0;
                }
 
                static inline HRESULT Make(FACILITY_TYPE eFacility, WORD wCode) noexcept
                {
                        return MAKE_HRESULT(1, eFacility, wCode);
                }
                static inline HRESULT Make(BYTE bReserved, FACILITY_TYPE eFacility, WORD wCode) noexcept
                {
                        return MAKE_HRESULT(1, eFacility, wCode) | (((HRESULT)bReserved) << (16 + 11));
                }
 
                static inline HRESULT FromWin32(DWORD dwWin32Code) noexcept
                {
                        if ((HRESULT)dwWin32Code <= 0)  // NO_ERROR
                        {
                                // <0 shouldn't happen! supposed to be unsigned. ASSUME its already a HRESULT code.
                                return ((HRESULT)dwWin32Code);  // already HRESULT failure. see GetLastError() docs.
                        }
                        if (dwWin32Code > 0xFFFF)
                        {
                                // This is weird ! NOT a proper error code !?
                                dwWin32Code &= 0xFFFF;
                        }
                        return HRESULT_WIN32_C(dwWin32Code);
                }
 
#ifdef _WIN32
                static inline HRESULT FromWaitRet(DWORD dwRet) noexcept
                {
                        if (dwRet == WAIT_FAILED)               // 0xFFFFFFFF
                                return E_HANDLE;
                        if (dwRet == WAIT_TIMEOUT)      // 258L
                                return HRESULT_WIN32_C(ERROR_WAIT_TIMEOUT);
                        if (dwRet >= STATUS_ABANDONED_WAIT_0)   // no idea.
                                return E_FAIL;
                        // WAIT_OBJECT_0 or STATUS_WAIT_0
                        return (HRESULT)dwRet;          // Wait signaled done. 0=event 0
                }
#endif
 
                static HRESULT GRAYCALL GetLast() noexcept;
 
                static inline HRESULT GetDef(HRESULT hRes, HRESULT hResDef = E_FAIL) noexcept
                {
                        if (SUCCEEDED(hRes) && FAILED(hResDef))
                        {
                                return hResDef; // Oddly no error was supplied! provide a default error.
                        }
                        return hRes;
                }
                static inline HRESULT GetLastDef(HRESULT hResDef = E_FAIL) noexcept
                {
                        return GetDef(GetLast(), hResDef);
                }
 
                static HRESULT GRAYCALL FromPOSIX(int iErrNo) noexcept; // from <errno.h> style
 
#ifndef UNDER_CE
                static HRESULT GRAYCALL GetPOSIXLast() noexcept;
                static HRESULT GRAYCALL GetPOSIXLastDef(HRESULT hResDef = E_FAIL) noexcept // static 
                {
                        return GetDef(GetPOSIXLast(), hResDef);
                }
#endif
 
                static void GRAYCALL AddCodes(const HResultCode* pCodes);
                static void GRAYCALL AddCodesDefault();
                static HRESULT GRAYCALL AddCodesText(const char* pszText);
                static HRESULT GRAYCALL AddCodesFile(const FILECHAR_t* pszFilePath);
 
                static const char* GRAYCALL GetTextBase(HRESULT hRes);
                static StrLen_t GRAYCALL GetTextSys(HRESULT hRes, GChar_t* lpszError, StrLen_t nLenMaxError, void* pSource = nullptr, va_list vargs = k_va_list_empty);
                static StrLen_t GRAYCALL GetTextV(HRESULT hRes, GChar_t* lpszError, StrLen_t nLenMaxError, void* pSource = nullptr, va_list vargs = k_va_list_empty);
 
                static HRESULT GRAYCALL GetHResFromStr(const GChar_t* pszError, StrLen_t nLenError = -1);
 
                UNITTEST_FRIEND(HResult);
        };
}
 
#endif // _INC_HResult_H