GxFile.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxFileInformation : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_CLASS(GxFileInformation, GxClassBase)
 
public:
    enum ATTRIBUTE
    {
        ATTRIBUTE_NOTHING   = 0,                            
        ATTRIBUTE_DIRECTORY = (1 << 0),                     
        ATTRIBUTE_ARCHIVE   = (1 << 1),                     
        ATTRIBUTE_READONLY  = (1 << 2),                     
        ATTRIBUTE_HIDDEN    = (1 << 3),                     
        ATTRIBUTE_SYSTEM    = (1 << 4),                     
        ATTRIBUTE_NORMAL    = (1 << 5),                     
 
        ATTRIBUTE_NUM       = 6                             
    };
 
    // friend宣言
    friend class GxFile;
#if defined(_PS5)
private:
    static constexpr u32 DIRECTORY_ENTRY_BUFFER_SIZE = GxMath::VALUE_4K;
#endif //_PS5
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxFileInformation(void);
    ~GxFileInformation(void) override { findClose(); }
 
    GxFileInformation(const GxFileInformation& fileInformation);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 operator == (const GxFileInformation& information)  const   { return (information.getName().compare(this->getName()) == 0); }
    b32 operator != (const GxFileInformation& information)  const   { return (information.getName().compare(this->getName()) != 0); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr u32 getAttribute(void)                        const   { return _attribute; }
    GX_FORCE_INLINE b32 isDirectory(void)                   const   { return (_attribute & ATTRIBUTE_DIRECTORY); }
    constexpr u64 getLastWriteTime(void)                    const   { return _lastWriteTime; }
    GX_FORCE_INLINE const GxString& getLastWriteTimeString(void)    const   { return _lastWriteTimeString; }
    GX_FORCE_INLINE const GxString& getName(void)           const   { return _filename; }
    constexpr u64 getSize(void)                             const   { return _size; }
 
#if !defined(_NX64)
    static u64 getWindowsTimeFromUnixTime(time_t unixTime);
    static time_t getUnixTimeFromWindowsTime(u64 windowsTime);
#endif //_NX64
 
    void setInformation(GX_CSTR filename, u64 size, u64 lastWriteTime, u32 attribute);
 
private:
    void setInformation(GX_CSTR path, const GxNativeFileEntry& findData);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    b32 findFirst(GX_CSTR path);
    b32 findNext(void);
    void findClose(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxNativeFindHandle  _findHandle;                            
#if defined(_PS4) || defined(_PS5)
    GxNativeFindBuffer  _findBuffer;                            
#endif  // _PS4 || _PS5
#if defined(_PS5)
    u32                 _findBufferIndex;                       
#endif  // _PS5
#if defined(_WINDOWS) || defined(_XBOX_XS)
#if GX_DEVELOP
    GX_HANDLE           _debugHandle;                           
#endif  // GX_DEVELOP
#endif  // _WINDOWS || _XBOX_XS
#if defined(_NX64) || defined(_PS5)
    GxString            _findPath;                              
#endif  // _NX64
    u64                 _size;                                  
    GxString            _filename;                              
    u64                 _lastWriteTime;                         
    GxString            _lastWriteTimeString;                   
    u32                 _attribute;                             
    GxString            _attributeString;                       
 
};
 
//===========================================================================
//===========================================================================
class GxFile : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxFile, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxFile)
 
    // friend宣言
    friend class GxSysFile;
 
public:
#if defined(_PS4) || defined(_PS5)
    static constexpr u32 FILE_PATH_MAX = GxMath::VALUE_1K;
#elif defined(_WINDOWS) || defined(_XBOX_XS)
    static constexpr u32 FILE_PATH_MAX = MAX_PATH;
#elif defined(_NX64)
    static constexpr u32 FILE_PATH_MAX = 260;
#endif // _NX64
 
    static constexpr u32 SECTOR_SIZE_MAX = GxMath::VALUE_2K;
 
    enum class MODE
    {
        READ = 1,                                   
        WRITE,                                      
        READWRITE,                                  
        TEMPORARY                                   
    };
 
    enum class PROCESS_TYPE
    {
        SYNC = 0,                                   
        ASYNC                                       
    };
 
    enum class SEEK_TYPE
    {
        BEGIN = 0,                                  
        CURRENT,                                    
        END,                                        
        MAX                                         
    };
 
    enum class STATE
    {
        INITIALIZED = 0,                            
        OPENED                                      
    };
 
    enum class ASYNC_STATE
    {
        NONE = 0,                                   
        PROGRESS,                                   
        COMPLETE                                    
    };
 
    enum class ASYNC_ERROR
    {
        CANCEL = -2,                                
        INVALID = -1,                               
        NONE    = 0                                 
    };
 
    typedef void (*FILE_ASYNC_READ_USER_CALLBACK)(void* pUser, GxFile& file, u32 size);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxFile(void);
    ~GxFile(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 open(GX_CSTR filename, MODE mode, PROCESS_TYPE type = PROCESS_TYPE::SYNC);
    void close(void);
    u32 read(void* pDst, u32 size);
    u32 write(const void* pSrc, u32 size);
    u32 seek(s32 offset, SEEK_TYPE seekType = SEEK_TYPE::BEGIN);
    void flush(void);
    b32 setLastWriteTime(u64 time);
 
 
    b32 readAsync(void* pDst, u32 size, FILE_ASYNC_READ_USER_CALLBACK userCallback = nullptr, void* pUser = nullptr);
 
    static b32 find(GxFileInformation& fileInfo, GX_CSTR path = nullptr);
    static b32 move(GX_CSTR srcPath, GX_CSTR dstPath);
    static b32 copy(GX_CSTR srcPath, GX_CSTR dstPath);
    static b32 remove(GX_CSTR path);
    static b32 createDirectory(GX_CSTR path);
    static b32 createDirectoryEx(GX_CSTR path, b32 isRecursive = false);
    static b32 removeDirectory(GX_CSTR path);
    static b32 isExist(GX_CSTR path);
    static b32 isDirectory(GX_CSTR path);
    static u64 getLastWriteTime(GX_CSTR path);
 
    GX_FORCE_INLINE static b32 move(const GxString& src, const GxString& dst)       { return move(src.getString(), dst.getString()); }
    GX_FORCE_INLINE static b32 copy(const GxString& src, const GxString& dst)       { return copy(src.getString(), dst.getString()); }
    GX_FORCE_INLINE static b32 remove(const GxString& path)                         { return remove(path.getString()); }
    GX_FORCE_INLINE static b32 createDirectory(const GxString& path)                { return createDirectory(path.getString()); }
    GX_FORCE_INLINE static b32 createDirectoryEx(const GxString& path)              { return createDirectoryEx(path.getString()); }
    GX_FORCE_INLINE static b32 removeDirectory(const GxString& path)                { return removeDirectory(path.getString()); }
    GX_FORCE_INLINE static b32 isExist(const GxString& path)                        { return isExist(path.getString()); }
    GX_FORCE_INLINE static b32 isDirectory(const GxString& path)                    { return isDirectory(path.getString()); }
    GX_FORCE_INLINE static u64 getLastWriteTime(const GxString& path)               { return getLastWriteTime(path.getString()); }
 
private:
#if defined(_WINDOWS) || defined(_XBOX_XS)
    static void CALLBACK callbackAsyncRead(DWORD error, DWORD size, LPOVERLAPPED pOverlapped);
#endif  // _WINDOWS || _XBOX_XS
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr u32 getPosition(void)                         const   { return _currentPosition; }
    constexpr u32 getSize(void)                             const   { return _size; }
    GX_FORCE_INLINE GX_CSTR getPath(void)                   const   { return _path.getString(); }
    GX_FORCE_INLINE b32 isOpened(void)                      const   { return (_state != STATE::INITIALIZED); }
    GX_FORCE_INLINE b32 isReadable(void)                    const   { return (static_cast<s32>(_mode) & static_cast<s32>(MODE::READ)) != 0; }
    GX_FORCE_INLINE b32 isWritable(void)                    const   { return (static_cast<s32>(_mode) & static_cast<s32>(MODE::WRITE)) != 0; }
    constexpr MODE getMode(void)                            const   { return _mode; }
    constexpr STATE getState(void)                          const   { return _state; }
    GX_FORCE_INLINE b32 isAsync(void)                       const   { return _isAsync; }
    constexpr ASYNC_STATE getAsyncState(void)               const   { return _asyncState; }
    constexpr ASYNC_ERROR getAsyncError(void)               const   { return _asyncError; }
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxNativeFileHandle              _handle;                    
#if defined(_WINDOWS) || defined(_XBOX_XS)
    OVERLAPPED                      _overlapped;                
#endif  // _WINDOWS || _XBOX_XS
#if GX_DEVELOP
    GX_HANDLE                       _debugHandle;               
#endif  // GX_DEVELOP
    GxString                        _path;                      
    STATE                           _state;                     
    MODE                            _mode;                      
    u32                             _size;                      
    u32                             _currentPosition;           
    b32                             _isAsync;                   
    ASYNC_STATE                     _asyncState;                
    ASYNC_ERROR                     _asyncError;                
    FILE_ASYNC_READ_USER_CALLBACK   _pUserCallback;             
    void*                           _pUserPointer;              
 
};
 
//===========================================================================
//===========================================================================
class GxFilePath : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxFilePath, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxFilePath)
 
public:
    static constexpr GX_CCHAR DEFAULT_SEPARATOR = '/';
    static constexpr GX_CCHAR REPLACE_SEPARATOR = '\\';
    static constexpr GX_CCHAR SYSTEM_SEPARATOR  = '/';
    static constexpr GX_CCHAR SYSTEM_REPLACE    = '\\';
 
private:
    static constexpr u32 SEPARATOR_REPEAT_PATH_LENGTH = 2;
    static constexpr u32 NETWORK_PATH_LENGTH          = 2;
    static constexpr u32 MOVEUP_DIRECTORY_PATH_LENGTH = 3;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxFilePath(void) : _separator(0){}
public:
    GxFilePath(GX_CSTR path, GX_CCHAR separator = DEFAULT_SEPARATOR, b32 isAbsolutePath = false);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE const GxString& getFullPath(void)                       const   { return _fullPath; }
    GX_FORCE_INLINE const GxString& getDirectoryPath(void)                  const   { return _directoryPath; }
    GX_FORCE_INLINE const GxString& getFileName(void)                       const   { return _fileName; }
    GX_FORCE_INLINE const GxString& getFileNameWithoutExtension(void)       const   { return _baseFileName; }
    GX_FORCE_INLINE const GxString& getExtension(void)                      const   { return _extension; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void addDirectoryPath(GX_CSTR folderName);
    void reduceDirectoryPath(void);
    GX_FORCE_INLINE static b32  isSeparator(GX_CCHAR character)         { return ((character == '/') | (character == '\\')); }
    GX_FORCE_INLINE static b32  isPeriod(GX_CCHAR character)            { return (character == '.'); }
    GX_FORCE_INLINE static b32  isNetworkPath(GX_CSTR path)             { return (isSeparator(path[0]) && isSeparator(path[1])); }
    GX_FORCE_INLINE static b32  isMoveUpDirectoryPath(GX_CSTR path)     { return (isSeparator(path[0]) && isPeriod(path[1]) && isPeriod(path[2])); }
    static b32  isRootPath(GX_CSTR path);
    static b32  isDirectoryPath(GX_CSTR path, GX_CCHAR separator = DEFAULT_SEPARATOR);
    static b32  isRelativePath(GX_CSTR path);
    static b32  convertSeparator(GX_STR path, GX_CCHAR separator = DEFAULT_SEPARATOR);
    static void normalize(GxString& path, GX_CCHAR separator = DEFAULT_SEPARATOR);
    static b32  extractFileName(GxString& dst, GX_CSTR path, GX_CCHAR separator = DEFAULT_SEPARATOR);
    static b32  extractFileNameWithoutExtension(GxString& dst, GX_CSTR path, GX_CCHAR separator = DEFAULT_SEPARATOR);
    static b32  extractExtension(GxString& dst, GX_CSTR path, GX_CCHAR separator = DEFAULT_SEPARATOR);
    static b32  addExtension(GxString& dst, GX_CSTR path, GX_CSTR extension, GX_CCHAR separator = DEFAULT_SEPARATOR);
    static b32  deleteExtension(GxString& dst, GX_CCHAR separator = DEFAULT_SEPARATOR);
    static b32  deleteExtension(GxString& dst, GX_CSTR path, GX_CCHAR separator = DEFAULT_SEPARATOR);
    static b32  isExistExtension(GX_CSTR path, GX_CCHAR separator = DEFAULT_SEPARATOR);
    static void addDirectoryPath(GxString& dst, const GxString& src, const GxString& directory, GX_CCHAR separator = DEFAULT_SEPARATOR);
    static b32  getRelativePath(GxString& dst, GX_CSTR basePath, GX_CSTR targetPath, b32 isUseDirectorySupport = true);
 
private:
    void analyse(const GxString& srcPath);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GX_CHAR                 _separator;                             
    GxString                _fullPath;                              
    GxString                _directoryPath;                         
    GxString                _fileName;                              
    GxString                _baseFileName;                          
    GxString                _extension;                             
 
};
 
GX_CORE_NAMESPACE_END()