cOSHandle.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cOSHandle_H
#define _INC_cOSHandle_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "HResult.h"
#include "cTimeSys.h" // TIMESYSD_t
#include "cNonCopyable.h"
#include "cUnitTestDecl.h"
#include "cDebugAssert.h"
 
namespace Gray
{
#define HANDLE_NULL             NULL    
 
#define WINHANDLE_NULL  NULL    
 
#ifdef __linux__
        typedef int HANDLE;                     
        static const HANDLE INVALID_HANDLE_VALUE = ((HANDLE)-1); 
 
        typedef void* HMODULE;          
        typedef void* HINSTANCE;
#endif
 
        enum SEEK_ORIGIN_TYPE
        {
                SEEK_Set = 0,           
                SEEK_Cur = 1,           
                SEEK_End = 2,           
                SEEK_MASK = 0x0007,             
        };
 
#if defined(_MFC_VER) && ( _MFC_VER > 0x0600 )
        typedef LONGLONG        STREAM_OFFSET_t;
        typedef ULONGLONG       STREAM_SEEKRET_t;
        typedef ULONGLONG       STREAM_POS_t;           // same as FILE_SIZE_t.
#define USE_FILE_POS64
 
#else
        typedef LONG_PTR        STREAM_OFFSET_t;        
        typedef LONG_PTR        STREAM_SEEKRET_t;       
        typedef ULONG_PTR       STREAM_POS_t;           
 
#endif  // ! _MFC_VER
 
        class GRAYCORE_LINK cOSHandle : protected cNonCopyable
        {
 
        public:
                HANDLE m_h;
 
        protected: 
                void CloseHandleLast() noexcept
                {
                        // Assume destruction or my caller will clear m_h
                        if (!isValidHandle())
                                return;
                        CloseHandle(m_h);
                }
 
        public:
                explicit inline cOSHandle(HANDLE h = INVALID_HANDLE_VALUE) noexcept
                : m_h(h)
                {
                }
 
                cOSHandle(const cOSHandle& Handle) noexcept
                : m_h(Handle.Duplicate())
                {
                }
                cOSHandle& operator=(const cOSHandle& Handle)
                {
                        if (m_h != Handle.m_h)
                        {
                                AttachHandle(Handle.Duplicate());
                        }
                        return (*this);
                }
 
                inline ~cOSHandle()
                {
                        CloseHandleLast();
                }
 
                operator HANDLE () const noexcept
                {
                        return m_h;
                }
                HANDLE get_Handle() const noexcept
                {
                        return m_h;
                }
                HANDLE& ref_Handle() noexcept
                {
                        return m_h;
                }
 
                static bool inline IsValidHandle(HANDLE h) noexcept
                {
#ifdef _WIN32
                        if (h == HANDLE_NULL)   
                                return false;
#endif
                        return(h != INVALID_HANDLE_VALUE);      //  -1
                }
                bool isValidHandle() const noexcept
                {
                        return IsValidHandle(m_h);
                }
 
                static inline bool CloseHandle(HANDLE h) noexcept // static
                {
#ifdef _WIN32
                        const BOOL bRet = ::CloseHandle(h); // ignored bool return.
                        return bRet;
#elif defined(__linux__)
                        const int iRet = ::close(h);
                        return iRet == 0;
#endif
                }
                void CloseHandle() noexcept
                {
                        if (!isValidHandle())
                                return;
                        HANDLE h = m_h;
                        m_h = INVALID_HANDLE_VALUE;
                        CloseHandle(h);
                }
 
#ifdef __linux__
                void OpenHandle( const char* pszPath, UINT uFlags, UINT uMode=0)
                {
                        CloseHandleLast();
                        m_h = ::open(pszPath, uFlags, uMode);
                }
#endif
 
                void AttachHandle(HANDLE h) noexcept
                {
                        if (m_h != h)
                        {
                                CloseHandleLast();
                                m_h = h;
                        }
                }
                HANDLE DetachHandle() noexcept
                {
                        HANDLE h = m_h;
                        m_h = INVALID_HANDLE_VALUE;
                        return h;
                }
 
                HRESULT WriteX(const void* pData, size_t nDataSize) const
                {
 
                        if (nDataSize <= 0)     // Do nothing.
                                return S_OK;
#if defined(_WIN32)
                        DWORD nLengthWritten = 0;
                        const bool bRet = ::WriteFile(m_h, pData, (DWORD)nDataSize, &nLengthWritten, nullptr);
                        if (!bRet)
#elif defined(__linux__)
                        int nLengthWritten = ::write(m_h, (const char*)pData, (long)nDataSize);
                        if (nLengthWritten <= 0)
#endif
                        {
                                return HResult::GetLastDef(HRESULT_WIN32_C(ERROR_WRITE_FAULT)); // E_HANDLE = file handle m_h is bad. 
                        }
                        return (HRESULT) nLengthWritten;
                }
 
                HRESULT ReadX(void* pData, size_t nDataSize) const
                {
                        if (nDataSize <= 0)
                                return S_OK;
#ifdef _WIN32
                        DWORD nLengthRead;
                        const bool bRet = ::ReadFile(m_h, pData, (DWORD)nDataSize, &nLengthRead, nullptr);
                        if (!bRet)
#elif defined(__linux__)
                        int nLengthRead = ::read(m_h, pData, (long)nDataSize);
                        if (nLengthRead == 0)   // EOF 
                                return HRESULT_WIN32_C(ERROR_HANDLE_EOF);
                        if (nLengthRead < 0)
#endif
                        {
                                // ERROR_HANDLE_EOF = No more data = EOF.
                                return HResult::GetLastDef(HRESULT_WIN32_C(ERROR_READ_FAULT));
                        }
                        return (HRESULT) nLengthRead;
                }
 
                HRESULT FlushX() const
                {
#ifdef _WIN32
                        if (!::FlushFileBuffers(m_h))
#elif defined(__linux__)
                        int iRet = ::fsync(m_h);
                        if (iRet != 0)
#endif
                        {
                                return HResult::GetLastDef(HRESULT_WIN32_C(ERROR_WRITE_FAULT));
                        }
                        return S_OK;
                }
 
                STREAM_SEEKRET_t Seek(STREAM_OFFSET_t lOffset, SEEK_ORIGIN_TYPE eSeekOrigin) const
                {
#ifdef _WIN32
#ifdef USE_FILE_POS64
                        LARGE_INTEGER NewFilePointer;
                        NewFilePointer.QuadPart = lOffset;
                        const bool bRet = ::SetFilePointerEx(m_h, NewFilePointer, &NewFilePointer, eSeekOrigin);
                        if (!bRet)
                        {
                                return((STREAM_POS_t)-1);
                        }
                        return((STREAM_POS_t)NewFilePointer.QuadPart);
#else
                        return ::SetFilePointer(m_h, (LONG)lOffset, nullptr, eSeekOrigin);
#endif // USE_FILE_POS64
#else
                        return ::lseek(m_h, lOffset, eSeekOrigin);
#endif
                }
 
                HRESULT WaitForSingleObject(TIMESYSD_t dwMilliseconds) const;
 
#ifdef __linux__
                int IOCtl(int nCmd, void* pArgs) const;
                int IOCtl(int nCmd, int nArgs) const;
#endif
 
#if defined(_WIN32) && ! defined(UNDER_CE)
                DWORD GetInformation() const
                {
                        ASSERT(isValidHandle());
                        DWORD dwHandleInfo = 0;
                        if (!::GetHandleInformation(m_h, &dwHandleInfo))
                        {
                                return 0;
                        }
                        return dwHandleInfo;
                }
                bool SetInformation(DWORD dwMask, DWORD dwFlags) const
                {
                        ASSERT(isValidHandle());
                        const bool bRet = ::SetHandleInformation(m_h, dwMask, dwFlags);
                        return bRet;
                }
#endif
 
#ifdef _WIN32
                HANDLE Duplicate(HANDLE hTargetProcess = INVALID_HANDLE_VALUE, DWORD dwDesiredAccess = DUPLICATE_SAME_ACCESS, bool bInheritHandle = false, DWORD dwOptions = DUPLICATE_SAME_ACCESS) const
                {
                        ASSERT(isValidHandle());
                        HANDLE hNewHandle = INVALID_HANDLE_VALUE;
                        HANDLE hCurrentProcess = ::GetCurrentProcess();
                        if (hTargetProcess == INVALID_HANDLE_VALUE)
                                hTargetProcess = hCurrentProcess;
                        const bool bRet = ::DuplicateHandle(hCurrentProcess, m_h, hTargetProcess,
                                &hNewHandle, dwDesiredAccess, bInheritHandle, dwOptions);
                        UNREFERENCED_PARAMETER(bRet);
                        return hNewHandle;
                }
#elif defined(__linux__)
                HANDLE Duplicate() const
                {
                        // http://linux.about.com/library/cmd/blcmdl2_dup.htm
                        return ::dup(m_h);
                }
#endif
 
                UNITTEST_FRIEND(cOSHandle);
        };
 
};
#endif // _INC_cOSHandle_H