cFile.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cFile_H
#define _INC_cFile_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cObject.h"
#include "cStream.h"
#include "cTimeInt.h"
#include "cFilePath.h"
#include "cFileStatus.h"
#include "cOSHandle.h"
#include "cException.h"
 
#if defined(__linux__)
//#include <sys/types.h>
#include <fcntl.h>      // O_RDONLY
//#include <unistd.h>
struct _SECURITY_ATTRIBUTES;    // stub this out
#endif
 
namespace Gray
{
        UNITTEST2_PREDEF(cFile);
 
        enum OF_FLAGS_TYPE_
        {
#if defined(__linux__)
                OF_READ = O_RDONLY,     
                OF_WRITE = O_WRONLY,    
                OF_READWRITE = O_RDWR,  
                OF_APPEND = O_APPEND, 
                OF_CREATE = O_CREAT,    
 
                OF_SHARE_COMPAT = 0x00000000,   
                OF_SHARE_EXCLUSIVE = 0x00000000,        
                OF_SHARE_DENY_WRITE = 0x00000000,       
                OF_SHARE_DENY_READ = 0x00000000,        
                OF_SHARE_DENY_NONE = 0x00000000,        
 
                OF_EXIST = 0x00000000,  
#endif
 
#if defined(UNDER_CE)
                OF_READ = 0x0000,       
                OF_WRITE = 0x0001,      
                OF_READWRITE = 0x0002,  
                OF_APPEND = 0x0008,     
                OF_CREATE = 0x0100,     
 
                OF_SHARE_COMPAT = 0x00000000,
                OF_SHARE_EXCLUSIVE = 0x00000010,        
                OF_SHARE_DENY_WRITE = 0x00000020,       
                OF_SHARE_DENY_READ = 0x00000030,
                OF_SHARE_DENY_NONE = 0x00000040,
 
                OF_EXIST = 0x00004000,  
#endif
 
                OF_OPEN_MASK = 0x00FFFFFF,      
                // OF_CACHE_RAND                = 0x04000000,
                OF_CACHE_SEQ = 0x08000000,      
                OF_BINARY = 0x10000000, 
                OF_TEXT = 0x20000000,   
                OF_NONCRIT = 0x40000000,        
                // OF_TEXT_W            = 0x80000000,   //!< UNICODE text file. (set by use of wchar_t Read/WriteString functions)
        };
 
        typedef UINT32 OF_FLAGS_t;      
 
        class GRAYCORE_LINK cFileStatus;
        
#ifndef _MFC_VER
        typedef cExceptionHResult CFileException;
        class GRAYCORE_LINK CFile : public CObject      // replace the MFC version
        {
 
        public:
                cOSHandle m_hFile;              
        protected:
                cStringF m_strFileName;         
 
        protected:
                bool isFileOpen() const noexcept
                {
                        return m_hFile.isValidHandle();
                }
 
                // virtual BOOL Open( const TCHAR* lpszFileName, UINT nOpenFlags, CFileException* pError = nullptr ) = 0; // MFC def.
                HRESULT OpenCreate(cStringF sFilePath = "", OF_FLAGS_t nOpenFlags = OF_CREATE | OF_WRITE, _SECURITY_ATTRIBUTES* pSa = nullptr);
        public:
                virtual ~CFile()
                {
                        Close();
                }
 
                // virtual CString GetFilePath() const  // DO NOT USE this. It conflicts with the messed up version of MFC. 
 
#if defined(__linux__)
                HRESULT GetStatusSys(OUT cFileStatusSys& statusSys);
#endif
 
                // File Access
                virtual STREAM_SEEKRET_t Seek(STREAM_OFFSET_t lOffset = 0, SEEK_ORIGIN_TYPE eSeekOrigin = SEEK_Set);    // should be const ? but not in MFC !
                virtual STREAM_POS_t GetPosition() const;
                virtual STREAM_POS_t GetLength() const;
 
                virtual void SetLength(STREAM_SEEKRET_t dwNewLen);
                virtual void Close()
                {
                        m_hFile.CloseHandle();
                }
 
                HRESULT Write(const void* pData, size_t nDataSize);
                HRESULT Read(void* pData, size_t nDataSize)
                {
                        // don't call this directly use ReadX
                        return m_hFile.ReadX(pData, nDataSize);
                }
        };
#endif  // _MFC_VER
 
        class GRAYCORE_LINK cFile
                : public CFile
                , public cStream
        {
 
                typedef CFile SUPER_t;
 
        protected:
                static ITERATE_t sm_iFilesOpen; 
                OF_FLAGS_t m_nOpenFlags;                
 
        protected:
                HRESULT OpenSetup(cStringF sFilePath, OF_FLAGS_t uModeFlags);
 
        public:
                cFile()
                        : m_nOpenFlags(0)
                {
                }
                cFile(cStringF sFilePath, OF_FLAGS_t nOpenFlags)
                {
                        OpenX(sFilePath, nOpenFlags);
                }
                virtual ~cFile()
                {
                        Close();
                }
 
                virtual bool isValidCheck() const noexcept      
                {
#ifndef _MFC_VER
                        if (!CObject::isValidCheck())
                                return false;
#endif
                        if (!IS_TYPE_OF(CFile, this))   // structure definitions are valid..
                                return false;
                        return true;
                }
 
                virtual STREAM_SEEKRET_t Seek(STREAM_OFFSET_t lOffset = 0, SEEK_ORIGIN_TYPE eSeekOrigin = SEEK_Set) override
                {
                        return CFile::Seek(lOffset, eSeekOrigin);
                }
                virtual STREAM_POS_t GetPosition() const override
                {
                        return CFile::GetPosition();
                }
                virtual STREAM_POS_t GetLength() const override
                {
                        return CFile::GetLength();
                }
 
#ifdef _MFC_VER
                void SeekToBegin()
                {
                        CFile::SeekToBegin();
                }
                STREAM_POS_t SeekToEnd()
                {
                        return CFile::SeekToEnd();
                }
#else
                int Read(void* pData, size_t nDataSize)
                {
                        // Emulate MFC. Try not to call this directly. use ReadX.
                        return ReadX(pData, nDataSize);
                }
                void Write(const void* pData, size_t nDataSize)
                {
                        // Emulate MFC
                        WriteX(pData, nDataSize);
                }
#endif
 
                cStringF get_FilePath() const
                {
                        return cStringF(m_strFileName);
                }
                cStringF get_FileTitleX() const;        // MFC is CString return
                cStringF get_FileExt() const;
                bool IsFileExt(const FILECHAR_t* pszExt) const;
 
                // File Mode stuff.
                OF_FLAGS_t get_Mode() const noexcept
                {
                        return m_nOpenFlags & 0x00FFFFFF;       //
                }
                OF_FLAGS_t get_ModeFlags() const noexcept
                {
                        return m_nOpenFlags;
                }
                bool isModeWrite() const noexcept
                {
                        // Can i write ?
                        const OF_FLAGS_t nFlagsDir = (m_nOpenFlags & (OF_WRITE | OF_READ | OF_READWRITE));
                        return nFlagsDir == OF_WRITE || nFlagsDir == OF_READWRITE;
                }
                bool isModeRead() const noexcept
                {
                        // Can i read ?
                        const OF_FLAGS_t nFlagsDir = (m_nOpenFlags & (OF_WRITE | OF_READ | OF_READWRITE));
                        return nFlagsDir == OF_READ || nFlagsDir == OF_READWRITE;       // assume OF_READ = 0
                }
 
                // File Open/Close
                virtual bool isFileOpen() const
                {
#ifdef _MFC_VER
                        return m_hFile != CFile::hFileNull;
#else
                        return CFile::isFileOpen();
#endif
                }
 
                // MFC Open is BOOL return type.
                virtual HRESULT OpenX(cStringF sFilePath = "", OF_FLAGS_t nOpenFlags = OF_READ | OF_SHARE_DENY_NONE);
                virtual void Close(void) override;
 
                HANDLE DetachFileHandle();
 
                HRESULT OpenWait(cStringF sFilePath = "", OF_FLAGS_t nOpenFlags = OF_READ | OF_SHARE_DENY_NONE, TIMESYSD_t nWaitTime = 100);
                HRESULT OpenCreate(cStringF sFilePath = "", OF_FLAGS_t nOpenFlags = OF_CREATE | OF_WRITE, _SECURITY_ATTRIBUTES* pSa = nullptr);
 
                // File Access
                bool SetFileTime(const cTimeFile* lpCreationTime, const cTimeFile* lpAccessTime, const cTimeFile* lpLastWriteTime);
                bool SetFileTime(cTimeInt timeCreation, cTimeInt timeLastWrite);
                HRESULT GetFileStatus(OUT cFileStatus& attr) const;
 
                // cStream
                virtual HRESULT ReadX(void* pData, size_t nDataSize) override;
                virtual HRESULT WriteX(const void* pData, size_t nDataSize) override; // disambiguate.
                virtual HRESULT FlushX() override;
 
                static HRESULT GRAYCALL DeletePath(const FILECHAR_t* pszFileName);      // NOTE: MFC Remove() returns void
                static HRESULT GRAYCALL DeletePathX(const FILECHAR_t* pszFilePath, DWORD nFileFlags = 0);
                static HRESULT GRAYCALL LoadFile(const FILECHAR_t* pszFilePath, OUT cHeapBlock& block, size_t nSizeExtra = 0);
 
                UNITTEST_FRIEND(cFile);
        };      
} 
 
#endif // _INC_CFile_H