fx_stream.h

浏览该文件的文档.

 
//<<<+++OPENSOURCE
//<<<+++OPENSOURCE_LICENSE
//<<<+++OPENSOURCE_BEGIN LIC==FOXIT||LIC==GOOGLE
 
//<<<+++OPENSOURCE_MUST_BEGIN
#ifndef _FX_STREAM_H_
#define _FX_STREAM_H_
 
#ifndef _FX_MEMORY_H_
  #include "fx_memory.h"
#endif
//<<<+++OPENSOURCE_MUST_END
 
//*****************************************************************************
//* 文件夹访问
//*****************************************************************************
#if !defined(_FPDFAPI_MINI_) || (defined(_WIN32) && !defined(_FX_NO_WINDOWS_)) || _FXM_PLATFORM_ == _FXM_PLATFORM_LINUX_ || _FX_OS_ == _FX_ANDROID_ || _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
 
void* FX_OpenFolder(FX_LPCSTR path);
void* FX_OpenFolder(FX_LPCWSTR path);
 
FX_BOOL FX_GetNextFile(void* handle, CFX_ByteString& filename, FX_BOOL& bFolder, FX_LPCSTR absPath=NULL);
FX_BOOL FX_GetNextFile(void* handle, CFX_WideString& filename, FX_BOOL& bFolder, FX_LPCSTR absPath=NULL);
 
void FX_CloseFolder(void* handle);
 
FX_WCHAR FX_GetFolderSeparator();
 
#endif
 
#if _FX_OS_ != _FX_EMBEDDED_
//<<<+++OPENSOURCE_BEGIN LIC==FOXIT
FX_BOOL FX_CreateFolder(FX_LPCSTR path);
FX_BOOL FX_CreateFolder(FX_LPCWSTR path);
 
FX_BOOL FX_DeleteFolder(FX_LPCSTR path);
FX_BOOL FX_DeleteFolder(FX_LPCWSTR path);
 
FX_BOOL FX_IsFilePathExist(FX_LPCWSTR path);
//<<<+++OPENSOURCE_END
#endif
 
//*****************************************************************************
//* 文件访问
//*****************************************************************************
FX_DEFINEHANDLE(FX_HFILE)
 
  //<<<+++OPENSOURCE_MUST_BEGIN LIC==FOXIT
  #if _FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN32_MOBILE_ || _FX_OS_ == _FX_WIN64_
    #if defined(_FX_LARGEFILE_SUPPORT_)
 
      #define _FX_LARGEFILE_USED_
 
      #define FX_FILESIZE    FX_INT64
      #define FX_GETBYTEOFFSET32(a)  ((FX_BYTE)((a>>16)>>16))
      #define FX_GETBYTEOFFSET40(a)  ((FX_BYTE)(((a>>16)>>16)>>8))
      #define FX_GETBYTEOFFSET48(a)  ((FX_BYTE)(((a>>16)>>16)>>16))
      #define FX_GETBYTEOFFSET56(a)  ((FX_BYTE)((((a>>16)>>16)>>16)>>8))
    #else
 
      #define FX_FILESIZE    FX_INT32
      #define FX_GETBYTEOFFSET32(a)  0
      #define FX_GETBYTEOFFSET40(a)  0
      #define FX_GETBYTEOFFSET48(a)  0
      #define FX_GETBYTEOFFSET56(a)  0
    #endif
        #elif _FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_MACOSX_ || _FX_OS_ == _FX_IOS_ || _FX_OS_ == _FX_ANDROID_ || _FX_OS_==_FX_LINUX_EMBEDDED_
    #if defined(_FX_LARGEFILE_SUPPORT_)
 
      #define _FX_LARGEFILE_USED_
 
      #ifndef _LARGEFILE_SOURCE
        #define _LARGEFILE_SOURCE
      #endif
      #ifndef _LARGEFILE64_SOURCE
        #define _LARGEFILE64_SOURCE
      #endif
    #endif
    #if defined(_FX_LARGEFILE_SUPPORT_)
      #define FX_GETBYTEOFFSET32(a)  ((FX_BYTE)((a>>16)>>16))
      #define FX_GETBYTEOFFSET40(a)  ((FX_BYTE)(((a>>16)>>16)>>8))
      #define FX_GETBYTEOFFSET48(a)  ((FX_BYTE)(((a>>16)>>16)>>16))
      #define FX_GETBYTEOFFSET56(a)  ((FX_BYTE)((((a>>16)>>16)>>16)>>8))
    #else
      #define FX_GETBYTEOFFSET32(a)  0
      #define FX_GETBYTEOFFSET40(a)  0
      #define FX_GETBYTEOFFSET48(a)  0
      #define FX_GETBYTEOFFSET56(a)  0
    #endif
    #include <fcntl.h>
    #include <unistd.h>
    #include <sys/stat.h>
 
    #ifndef O_BINARY
      #define O_BINARY   0
    #endif
    #ifndef O_LARGEFILE
      #define O_LARGEFILE 0
    #endif
 
    #if defined(_FX_LARGEFILE_SUPPORT_)
      #if _FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_LINUX_EMBEDDED_ || _FX_OS_ == _FX_ANDROID_
        // mac 和 bsd 始终是 64 位。使用 off_t
        // Linux 和 Android 使用 off64_t
#ifndef _CHROME_PNACL_
        #define _FX_USE_OFF64_T_
#endif
      #endif
    #endif
    #if defined(_FX_USE_OFF64_T_)
      #define FX_FILESIZE    off64_t
                #elif _FX_OS_ == _FX_LINUX_EMBEDDED_
                        #define FX_FILESIZE FX_INT32
    #else
      #ifndef _CHROME_PNACL_
        #define FX_FILESIZE    off_t
      #else
        #define FX_FILESIZE    FX_INT32
      #endif
    #endif
  #else //不支持大文件。
 
    #define FX_FILESIZE    FX_INT32
    #define FX_GETBYTEOFFSET32(a)  0
    #define FX_GETBYTEOFFSET40(a)  0
    #define FX_GETBYTEOFFSET48(a)  0
    #define FX_GETBYTEOFFSET56(a)  0
  #endif
  //<<<+++OPENSOURCE_MUST_END
 
#define FX_GETBYTEOFFSET24(a)  ((FX_BYTE)(a>>24))
#define FX_GETBYTEOFFSET16(a)  ((FX_BYTE)(a>>16))
#define FX_GETBYTEOFFSET8(a)   ((FX_BYTE)(a>>8))
#define FX_GETBYTEOFFSET0(a)   ((FX_BYTE)(a))
 
#define FX_FILEMODE_Write    0
 
#define FX_FILEMODE_ReadOnly  1
 
#define FX_FILEMODE_Truncate  2  //
 
FX_HFILE  FX_File_Open(FX_BSTR fileName, FX_DWORD dwMode, IFX_Allocator* pAllocator = NULL);
FX_HFILE  FX_File_Open(FX_WSTR fileName, FX_DWORD dwMode, IFX_Allocator* pAllocator = NULL);
void    FX_File_Close(FX_HFILE hFile, IFX_Allocator* pAllocator = NULL);
//<<<+++OPENSOURCE_END
 
FX_FILESIZE  FX_File_GetSize(FX_HFILE hFile);
FX_FILESIZE  FX_File_GetPosition(FX_HFILE hFile);
FX_FILESIZE  FX_File_SetPosition(FX_HFILE hFile, FX_FILESIZE pos);
size_t    FX_File_Read(FX_HFILE hFile, void* pBuffer, size_t szBuffer);
size_t    FX_File_ReadPos(FX_HFILE hFile, void* pBuffer, size_t szBuffer, FX_FILESIZE pos);
size_t    FX_File_Write(FX_HFILE hFile, const void* pBuffer, size_t szBuffer);
size_t    FX_File_WritePos(FX_HFILE hFile, const void* pBuffer, size_t szBuffer, FX_FILESIZE pos);
FX_BOOL    FX_File_Flush(FX_HFILE hFile);
FX_BOOL    FX_File_Truncate(FX_HFILE hFile, FX_FILESIZE szFile);
 
FX_BOOL    FX_File_Exist(FX_BSTR fileName);
FX_BOOL    FX_File_Exist(FX_WSTR fileName);
FX_BOOL    FX_File_Delete(FX_BSTR fileName);
FX_BOOL    FX_File_Delete(FX_WSTR fileName);
FX_BOOL    FX_File_Copy(FX_BSTR fileNameSrc, FX_BSTR fileNameDst);
FX_BOOL    FX_File_Copy(FX_WSTR fileNameSrc, FX_WSTR fileNameDst);
FX_BOOL    FX_File_Move(FX_BSTR fileNameSrc, FX_BSTR fileNameDst);
FX_BOOL    FX_File_Move(FX_WSTR fileNameSrc, FX_WSTR fileNameDst);
 
//*****************************************************************************
//* IFX_StreamWrite/IFX_FileWrite
//*****************************************************************************
class IFX_StreamWrite
{
 public:
  virtual void    Release() = 0;
 
  virtual  FX_BOOL    WriteBlock(const void* pData, size_t size) = 0;
  virtual FX_BOOL    Flush() { return true; }
 
#if !defined(__EMSCRIPTEN__) && !defined(SWIGJAVA)
 protected:
#endif
  virtual ~IFX_StreamWrite() {}
};
 
class IFX_FileWrite : public IFX_StreamWrite
{
 public:
  virtual void      Release() = 0;
 
  virtual FX_FILESIZE    GetSize() = 0;
  virtual FX_BOOL      Flush() = 0;
  virtual  FX_BOOL      WriteBlock(const void* pData, FX_FILESIZE offset, size_t size) = 0;
  virtual  FX_BOOL      WriteBlock(const void* pData, size_t size) {return WriteBlock(pData, GetSize(), size);}
 
#if !defined(__EMSCRIPTEN__) && !defined(SWIGJAVA)
 protected:
#endif
  virtual ~IFX_FileWrite() {}
};
 
IFX_FileWrite* FX_CreateFileWrite(FX_LPCSTR filename, IFX_Allocator* pAllocator = NULL);
 
IFX_FileWrite* FX_CreateFileWrite(FX_LPCWSTR filename, IFX_Allocator* pAllocator = NULL);
//<<<+++OPENSOURCE_END
 
//*****************************************************************************
//* IFX_FileRead
//*****************************************************************************
class IFX_StreamRead
{
 public:
  virtual void      Release() = 0;
 
  virtual FX_BOOL      IsEOF() = 0;
  virtual FX_FILESIZE    GetPosition() = 0;
  virtual size_t      ReadBlock(void* buffer, size_t size) = 0;
 
  virtual FX_FILESIZE SetPosition(FX_FILESIZE pos) { FXSYS_assert(false && "Unsupport");  return -1; }
 
 protected:
  virtual ~IFX_StreamRead() {}
};
 
class IFX_FileRead : public IFX_StreamRead
{
 public:
  virtual void      Release() = 0;
 
  virtual FX_FILESIZE    GetSize() = 0;
  virtual FX_BOOL      IsEOF() {return false;}
  virtual FX_FILESIZE    GetPosition() {return 0;}
  virtual FX_BOOL      SetRange(FX_FILESIZE offset, FX_FILESIZE size) {return false;}
  virtual void      ClearRange() {}
  virtual FX_BOOL      ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) = 0;
  virtual size_t      ReadBlock(void* buffer, size_t size) {return 0;}
 
  virtual FX_FILESIZE           SetPosition(FX_FILESIZE pos) { FXSYS_assert(false && "Unsupport");  return -1; }
 
#if !defined(__EMSCRIPTEN__) && !defined(SWIGJAVA)
 protected:
#endif
  virtual ~IFX_FileRead() {}
};
 
IFX_FileRead* FX_CreateFileRead(FX_LPCSTR filename, IFX_Allocator* pAllocator = NULL);
 
IFX_FileRead* FX_CreateFileRead(FX_LPCWSTR filename, IFX_Allocator* pAllocator = NULL);
//<<<+++OPENSOURCE_END
 
//*****************************************************************************
//* IFX_FileStream
//*****************************************************************************
class IFX_FileStream 
: public IFX_FileRead, public IFX_FileWrite
{
 public:
  virtual IFX_FileStream*    Retain() = 0;
  virtual void        Release() = 0;
 
  virtual FX_FILESIZE      GetSize() = 0;
  virtual FX_BOOL        IsEOF() = 0;
  virtual FX_FILESIZE      GetPosition() = 0;
 
  virtual FX_BOOL        ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) = 0;
  virtual size_t        ReadBlock(void* buffer, size_t size) = 0;
 
  virtual  FX_BOOL        WriteBlock(const void* buffer, FX_FILESIZE offset, size_t size) = 0;
  virtual  FX_BOOL        WriteBlock(const void* buffer, size_t size) {return WriteBlock(buffer, GetSize(), size);}
 
  virtual FX_BOOL        Flush() = 0;
 
#if !defined(__EMSCRIPTEN__) && !defined(SWIGJAVA)
 protected:
#endif
  virtual ~IFX_FileStream() {}
};
 
IFX_FileStream*    FX_CreateFileStream(FX_LPCSTR filename, FX_DWORD dwModes, IFX_Allocator* pAllocator = NULL);
 
IFX_FileStream*    FX_CreateFileStream(FX_LPCWSTR filename, FX_DWORD dwModes, IFX_Allocator* pAllocator = NULL);
//<<<+++OPENSOURCE_END
 
//*****************************************************************************
//* IFX_ChunkFileStream
//*****************************************************************************
class IFX_ChunkFileStream : public IFX_FileStream
{
 public:
        virtual void Release() = 0;
 
        virtual FX_FILESIZE GetSize() = 0;
        virtual FX_BOOL IsEOF() = 0;
        virtual FX_FILESIZE GetPosition() = 0;
 
        virtual FX_BOOL ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) = 0;
        virtual size_t ReadBlock(void* buffer, size_t size) = 0;
 
        virtual FX_BOOL WriteBlock(const void* buffer, FX_FILESIZE offset, size_t size) = 0;
        virtual FX_BOOL WriteBlock(const void* buffer, size_t size)
        {
                return WriteBlock(buffer, GetSize(), size);
        }
 
        virtual FX_BOOL Flush() = 0;
 
 protected:
        virtual IFX_FileStream* Retain() = 0;
 
        virtual ~IFX_ChunkFileStream() {}
 
        friend class CFX_ChunkFileStreamsManager;
};
 
//*****************************************************************************
//* CFX_ChunkFileStreamsManager
//*****************************************************************************
class CFX_ChunkFileStreamsManagerImpl;
class CFX_ChunkFileStreamsManager : public CFX_Object
{
 public:
        CFX_ChunkFileStreamsManager(IFX_FileStream* pFileStream, size_t nChunkSize = 1024);
        ~CFX_ChunkFileStreamsManager();
 
        IFX_ChunkFileStream* CreateChunkFileStream();
 
 private:
        std::shared_ptr<CFX_ChunkFileStreamsManagerImpl> m_pImpl;
};
 
//*****************************************************************************
//* IFX_FileAccess
//*****************************************************************************
class IFX_FileAccess
{
 public:
  virtual void        Release() = 0;
 
  virtual IFX_FileAccess*    Retain() = 0;
  virtual void        GetPath(CFX_WideString& wsPath) = 0;
 
  virtual IFX_FileStream*    CreateFileStream(FX_DWORD dwModes) = 0;
 
 protected:
  virtual ~IFX_FileAccess() {}
};
 
IFX_FileAccess*    FX_CreateDefaultFileAccess(FX_WSTR  wsPath, IFX_Allocator* pAllocator = NULL);
 
class IFX_FileCollection
{
 public:
  virtual void        Release() = 0;
 
  virtual FX_POSITION      GetStartPos() = 0;
  virtual IFX_FileAccess*    GetNextFile(FX_POSITION& pos) = 0;
 
 protected:
  virtual ~IFX_FileCollection() {}
};
//<<<+++OPENSOURCE_END
 
//*****************************************************************************
//* 内存流
//*****************************************************************************
class IFX_MemoryStream : public IFX_FileStream
{
 public:
  virtual ~IFX_MemoryStream() {}
 
  virtual FX_BOOL      IsConsecutive() const = 0;
  virtual void      EstimateSize(size_t nInitSize, size_t nGrowSize) = 0;
  virtual FX_LPBYTE    GetBuffer() const = 0;
  virtual void      AttachBuffer(FX_LPBYTE pBuffer, size_t nSize, FX_BOOL bTakeOver = false) = 0;
  virtual void      DetachBuffer() = 0;
};
IFX_MemoryStream*  FX_CreateMemoryStream(FX_LPBYTE pBuffer, size_t nSize, FX_BOOL bTakeOver = false, IFX_Allocator* pAllocator = NULL);
 
IFX_MemoryStream*  FX_CreateMemoryStream(FX_BOOL bConsecutive = false, IFX_Allocator* pAllocator = NULL);
//<<<+++OPENSOURCE_END
 
//*****************************************************************************
//* 缓冲区流的读取
//*****************************************************************************
class IFX_BufferRead : public IFX_StreamRead
{
 public:
  virtual void      Release() = 0;
 
  virtual FX_BOOL      IsEOF() = 0;
  virtual FX_FILESIZE    GetPosition() = 0;
 
  virtual size_t      ReadBlock(void* buffer, size_t size) = 0;
 
  virtual FX_BOOL      ReadNextBlock(FX_BOOL bRestart = false) = 0;
  virtual FX_LPCBYTE    GetBlockBuffer() = 0;
  virtual size_t      GetBlockSize() = 0;
  virtual FX_FILESIZE    GetBlockOffset() = 0;
 
 protected:
  virtual ~IFX_BufferRead() {}
};
 
//*****************************************************************************
//* 缓存文件读取
//*****************************************************************************
#define FX_FILECACHE_CHUNKSIZE  32768
#define FX_FILECACHE_CHUNKCOUNT  64
 
class CFX_CachedFileRead : public IFX_FileStream, public CFX_Object
{
 public:
  CFX_CachedFileRead();
  virtual  ~CFX_CachedFileRead();
 
  FX_BOOL      Init(FX_INT32 nChunkSize, FX_INT32 nChunkCount, FX_LPVOID pBuffer, IFX_Allocator* pAllocator = NULL);
  FX_BOOL      AttachFile(IFX_FileRead* pFile, FX_BOOL bTakeOver);
  FX_BOOL      PreCache(FX_FILESIZE offset, FX_INT32 nCacheCount);
 
  virtual FX_FILESIZE    GetSize();
  virtual FX_BOOL      IsEOF();
  virtual FX_FILESIZE    GetPosition();
 
  virtual FX_BOOL      ReadBlock(void* buffer, FX_FILESIZE offset, size_t size);
  virtual size_t      ReadBlock(void* buffer, size_t size);
 
 protected:
  FXMT_LOCKOBJECT_DEFINE(m_LockObj);
  FX_LPVOID        m_pData;
  FX_DWORD        m_dwCount;
 
  /* @brief 创建共享实例。 */
  virtual IFX_FileStream*  Retain();
  /* @brief 当要释放所有资源时调用 */
  virtual void      Release();
  virtual  FX_BOOL      WriteBlock(const void* buffer, FX_FILESIZE offset, size_t size) {return false;}
  virtual FX_BOOL      Flush() {return false;}
};
//<<<+++OPENSOURCE_END
 
//<<<+++OPENSOURCE_MUST_BEGIN
#endif // _FX_STREAM_H_
//<<<+++OPENSOURCE_MUST_END
 
//<<<+++OPENSOURCE_END