cFileMem.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cFileMem_H
#define _INC_cFileMem_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cFile.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cFileMem : public cFile
        {
                // Does NOT use cOSHandle. So NOT inter-process.
 
                typedef cFile SUPER_t;
 
        private:
                BYTE* m_pDataStart;                     
                size_t m_nDataLength;           
                cHeapBlock m_Data;                      
                size_t m_nPosition;                     
 
        public:
                cFileMem() noexcept
                        : m_pDataStart(nullptr)
                        , m_nDataLength(0)
                        , m_nPosition(0)        // current read/write position
                {
                }
                virtual ~cFileMem() 
                {
                }
 
                virtual bool isFileOpen() const override 
                {
                        return(m_pDataStart != nullptr);
                }
                virtual HRESULT OpenX(cStringF sFilePath = "", OF_FLAGS_t nOpenFlags = OF_READ | OF_SHARE_DENY_NONE) override
                {
                        HRESULT hRes = OpenSetup(sFilePath, nOpenFlags);
                        m_nPosition = 0;
                        return hRes;
                }
                virtual STREAM_SEEKRET_t Seek(STREAM_OFFSET_t lOffset = 0, SEEK_ORIGIN_TYPE eSeekOrigin = SEEK_Set) override
                {
                        switch (eSeekOrigin)
                        {
                        default:
                        case SEEK_Set:  // FILE_BEGIN = SEEK_Set
                                m_nPosition = lOffset;
                                break;
                        case SEEK_Cur:  // FILE_CURRENT = SEEK_CUR
                                m_nPosition += lOffset;
                                break;
                        case SEEK_End:  // FILE_END
                                m_nPosition = m_nDataLength + lOffset;
                                break;
                        }
                        return m_nPosition;
                }
                virtual STREAM_POS_t GetPosition() const override
                {
                        return m_nPosition;
                }
                virtual STREAM_POS_t GetLength() const override
                {
                        return m_nDataLength;
                }
 
                bool isLengthStatic() const noexcept
                {
                        return(m_nDataLength != 0 && !m_Data.isValidPtr());
                }
 
                virtual void SetLength(STREAM_SEEKRET_t dwNewLen) override
                {
                        if (isLengthStatic())
                        {
                                ASSERT(0);
                                return;
                        }
                        m_nDataLength = dwNewLen;
                        m_Data.ReAlloc(dwNewLen);
                        m_pDataStart = m_Data.get_DataBytes();
                }
 
                virtual HRESULT ReadX(void* pData, size_t nDataSize) override;
                virtual HRESULT WriteX(const void* pData, size_t nDataSize) override;
 
                void SetDataStatic(void* pDataStart, size_t nDataSize)
                {
                        m_pDataStart = (BYTE*)pDataStart;
                        m_nDataLength = nDataSize;
                        m_Data.Free();
                        ASSERT(isLengthStatic());
                }
                void SetDataStr(const char* pszData)
                {
                        SetDataStatic((BYTE*)pszData, StrT::Len(pszData));
                }
                void SetDataStr(const char* pszData, StrLen_t nDataChars)
                {
                        nDataChars = MIN(StrT::Len(pszData), nDataChars);
                        SetDataStatic((BYTE*)pszData, nDataChars);
                }
                void SetDataCopy(const BYTE* pDataStart, size_t nDataSize)
                {
                        SetLength(nDataSize);
                        memcpy(m_pDataStart, pDataStart, nDataSize);
                }
 
                UNITTEST_FRIEND(cFileMem);
        };
};
#endif