cFileDir.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cFileDir_H
#define _INC_cFileDir_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cArrayString.h"
#include "cFile.h"
#include "cFileStatus.h"
#include "cTimeInt.h"
#include "cString.h"
#include "HResult.h"
 
#ifdef __linux__
#include <dirent.h>     // DIR
#endif
 
enum FOF_TYPE_
{
#ifdef __linux__
        FOF_ALLOWUNDO = 0x0040,         // 0x0040 in WIN32 <shellapi.h> 
        FOF_FILESONLY = 0x0080,         // 0x0080 in WIN32 <shellapi.h> 
        FOF_RENAMEONCOLLISION = 0x0100, // 8 in WIN32 (FOF_SIMPLEPROGRESS)
        FOF_NOERRORUI = 0x400,          // 0x0400  in WIN32 <shellapi.h>
#endif
        // NON WIN32 standard.
        FOF_X_FollowLinks = 0x10000,
        FOF_X_WantDots = 0x20000,
#if ! USE_UNICODE_FN
        FOF_X_UTF8 = 0x40000,                   
#endif
};
 
namespace Gray
{
        UNITTEST2_PREDEF(cFileDir);
 
#ifdef _WIN32
#define FILEDEVICE_PREFIX       "\\\\.\\"       // usually _FN(FILEDEVICE_PREFIX). similar to "\\Device\\"
#elif defined(__linux__)
#define FILEDEVICE_PREFIX       "/dev/"
#endif
 
        class GRAYCORE_LINK cFileDevice
        {
        public:
                static const char* k_FileSysName[FILESYS_QTY];          
 
                // _WIN32 Info from GetVolumeInformation();
                cStringF m_sVolumeName;         
                cStringF m_sTypeName;           
                FILESYS_TYPE m_eType;           
                UINT64 m_nSerialNumber;         
                DWORD m_dwMaximumComponentLength;       
                bool m_bCaseSensitive;                  
 
        public:
                cFileDevice();
                ~cFileDevice();
 
                HRESULT UpdateInfo(const FILECHAR_t* pszDeviceId = nullptr);
 
                FILESYS_TYPE get_FileSysType() const
                {
                        return m_eType;
                }
                bool isCaseSensitive() const;
 
                static UINT GRAYCALL GetDeviceType(const FILECHAR_t* pszDeviceId);
                static FILE_SIZE_t GRAYCALL GetDeviceFreeSpace(const FILECHAR_t* pszDeviceId = nullptr);
                static HRESULT GRAYCALL GetSystemDeviceList(cArrayString<FILECHAR_t>& a);
        };
 
        class GRAYCORE_LINK cFileFindEntry
                : public cFileStatus
        {
                typedef cFileStatus SUPER_t;
                typedef cFileFindEntry THIS_t;
 
        public:
                cStringF m_sFileName;   
 
        public:
                cFileFindEntry()
                {
                        InitFileStatus();
                }
                explicit cFileFindEntry(const FILECHAR_t* pszFileName)
                        : m_sFileName(pszFileName)
                {
                        InitFileStatus();
                }
                cFileFindEntry(const FILECHAR_t* pszFileName, const cFileStatus& status)
                        : cFileStatus(status)
                        , m_sFileName(pszFileName)
                {
                }
                bool IsFileEqualTo(const THIS_t& rEntry) const
                {
                        // Does file system use case ?
                        if (m_sFileName.CompareNoCase(rEntry.m_sFileName) != 0)
                                return false;
                        return SUPER_t::IsFileEqualTo(rEntry);
                }
                bool IsFileEqualTo(const THIS_t* pEntry) const
                {
                        // Does file system use case ?
                        if (pEntry == nullptr)
                                return false;
                        return IsFileEqualTo(*pEntry);
                }
                bool operator == (const THIS_t& rEntry) const
                {
                        return IsFileEqualTo(rEntry);
                }
                bool operator != (const THIS_t& rEntry) const
                {
                        return !IsFileEqualTo(rEntry);
                }
                bool isDot() const
                {
                        if (m_sFileName[0] != '.')
                                return false;
                        if (m_sFileName[1] == '\0')
                                return true;
                        return false;
                }
                bool isDots() const noexcept
                {
                        if (m_sFileName[0] != '.')
                                return false;
                        if (m_sFileName[1] == '\0')
                                return true;
                        if (m_sFileName[1] != '.')
                                return false;
                        if (m_sFileName[2] == '\0')
                                return true;
                        return false;
                }
                cStringF get_Name() const
                {
                        return m_sFileName;
                }
        };
 
        class GRAYCORE_LINK cFileFind
        {
 
        public:
                cFileFindEntry m_FileEntry;     
 
        private:
                cStringF m_sDirPath;                    
                DWORD m_nFileFlags;                             
#ifdef _WIN32
                WIN32_FIND_DATAW m_FindInfo;    
                HANDLE m_hContext;                              
#elif defined(__linux__)
                cStringF m_sWildcardFilter;             
        public:
                bool m_bReadStats;                              
        private:
                DIR* m_hContext;                                
#else
#error NOOS
#endif
 
        public:
                explicit cFileFind(cStringF sDirPath = "", DWORD nFileFlags = 0) noexcept;
                ~cFileFind()
                {
                        CloseContext();
                }
 
                cStringF get_DirPath() const noexcept
                {
                        return m_sDirPath;
                }
                cStringF GetFilePath(const FILECHAR_t* pszFileTitle) const
                {
                        return cFilePath::CombineFilePathX(m_sDirPath, pszFileTitle);
                }
                cStringF get_FilePath() const
                {
                        return cFilePath::CombineFilePathX(m_sDirPath, m_FileEntry.m_sFileName);
                }
                bool isDots() const noexcept
                {
                        return m_FileEntry.isDots();
                }
 
                HRESULT FindOpen(const FILECHAR_t* pszDirPath = nullptr, const FILECHAR_t* pszWildcardFile = nullptr);
                HRESULT FindFile(const FILECHAR_t* pszDirPath = nullptr, const FILECHAR_t* pszWildcardFile = nullptr);
                HRESULT FindFileNext(bool bFirst = false);
 
                bool isContextOpen() const;
                void CloseContext();
        };
 
        class GRAYCORE_LINK cFileDir
        {
        public:
                static const int k_FilesMax = 64 * 1024;
                static const LOGCHAR_t k_szCantMoveFile[];      
 
                cArrayStruct<cFileFindEntry> m_aFiles;  
 
        protected:
                cStringF m_sDirPath;    
 
        protected:
                virtual HRESULT AddFileDirEntry(cFileFindEntry& FileEntry)
                {
                        if (!FileEntry.isDots())
                        {
                                m_aFiles.Add(FileEntry);
                        }
                        return S_OK;
                }
 
        public:
                explicit cFileDir(cStringF sDirPath = _FN(""))
                        : m_sDirPath(sDirPath)
                {
                }
                virtual ~cFileDir()
                {
                }
 
                static HRESULT GRAYCALL RemoveDirectory1(const FILECHAR_t* pszDirName);
                static HRESULT GRAYCALL CreateDirectory1(const FILECHAR_t* pszDirName);
                static HRESULT GRAYCALL CreateDirectoryX(const FILECHAR_t* pszDirName);
                static HRESULT GRAYCALL CreateDirForFileX(const FILECHAR_t* pszFilePath);
                static HRESULT GRAYCALL MovePathToTrash(const FILECHAR_t* pszPath, bool bDir);
 
                static HRESULT GRAYCALL DirFileOp(FILEOP_TYPE eOp, const FILECHAR_t* pszDirSrc, const FILECHAR_t* pszDirDest, DWORD nFileFlags, cLogProcessor* pLog, IStreamProgressCallback* pProgress);
                static HRESULT GRAYCALL MoveDirFiles(const FILECHAR_t* pszDirSrc, const FILECHAR_t* pszDirDest, cLogProcessor* pLog = nullptr, IStreamProgressCallback* pProgress = nullptr)
                {
                        return DirFileOp(FILEOP_MOVE, pszDirSrc, pszDirDest, 0, pLog, pProgress);
                }
                static HRESULT GRAYCALL CopyDirFiles(const FILECHAR_t* pszDirSrc, const FILECHAR_t* pszDirDest, cLogProcessor* pLog = nullptr, IStreamProgressCallback* pProgress = nullptr)
                {
                        return DirFileOp(FILEOP_COPY, pszDirSrc, pszDirDest, 0, pLog, pProgress);
                }
                static HRESULT GRAYCALL DeleteDirFiles(const FILECHAR_t* pszDirName, const FILECHAR_t* pszWildcardFile = nullptr, DWORD nFileFlags = 0)
                {
                        return DirFileOp(FILEOP_DELETE, pszDirName, pszWildcardFile, nFileFlags, nullptr, nullptr);
                }
 
                static HRESULT GRAYCALL DeletePathX(const FILECHAR_t* pszPath, DWORD nFileFlags = 0);
 
                cStringF get_DirPath() const
                {
                        return m_sDirPath;
                }
                void put_DirPath(cStringF sDirPath)
                {
                        m_sDirPath = sDirPath;
                        // clear list only if changed?
                        RemoveAll();
                }
                ITERATE_t get_FileCount() const
                {
                        return m_aFiles.GetSize();
                }
                const cFileFindEntry& GetEnumFile(ITERATE_t i) const
                {
                        return m_aFiles.ConstElementAt(i);
                }
                cFileFindEntry& GetEnumFile(ITERATE_t i)
                {
                        return m_aFiles.ElementAt(i);
                }
                cStringF GetEnumTitleX(ITERATE_t i) const
                {
                        ASSERT(m_aFiles.IsValidIndex(i));
                        const cFileFindEntry& rFileEntry = m_aFiles.ConstElementAt(i);
                        return rFileEntry.m_sFileName;
                }
                cStringF GetEnumPath(ITERATE_t i) const
                {
                        return GetFilePath(GetEnumTitleX(i));
                }
 
                cStringF GetFilePath(const FILECHAR_t* pszTitle) const
                {
                        return cFilePath::CombineFilePathX(m_sDirPath, pszTitle);
                }
                void RemoveAll()
                {
                        m_aFiles.RemoveAll();
                }
 
                HRESULT ReadDir(const FILECHAR_t* pszDirPath = nullptr, const FILECHAR_t* pszWildcardFile = nullptr, ITERATE_t iFilesMax = k_FilesMax, bool bFollowLink = false);
 
                HRESULT ReadDirAnyExt(const FILECHAR_t* pszFilePath, ITERATE_t iFilesMax = k_FilesMax);
                HRESULT ReadDirPreferredExt(const FILECHAR_t* pszFilePath, const FILECHAR_t* const* pszExtTable);
 
                UNITTEST_FRIEND(cFileDir);
        };
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
        template class GRAYCORE_LINK CArray < cFileFindEntry, const cFileFindEntry& >;
        template class GRAYCORE_LINK cArrayTyped < cFileFindEntry, const cFileFindEntry& >;
        template class GRAYCORE_LINK cArrayStruct < cFileFindEntry >;
#endif
 
}
 
#endif  // _INC_cFileDir_H