builds/digitalwerk/solutions/adtf_content/adtf_base/adtf_core/src/libraries/a_utils/include/a_utils/core/filesystem.h

Go to the documentation of this file.

 
#ifndef _FILESYSTEM_CLASS_HEADER_
#define _FILESYSTEM_CLASS_HEADER_
 
namespace A_UTILS_NS
{
 
class DOEXPORT cFileAttributes
{
    public:
        tBool        bValid;        
        tBool        bReadOnly;     
        tBool        bFolder;       
        tBool        bHidden;       
        tBool        bSystem;       
        tBool        bArchive;      
        tBool        bCompressed;   
        tBool        bEncrypted;    
        tBool        bOffline;      
        tBool        bSymLink;      
        tBool        bPipe;         
        tBool        bBlockDevice;  
        tBool        bCharDevice;   
 
        typedef enum
        {
            #ifdef WIN32
                // map to Win32 definitions
                ATTRIBUTE_READONLY      = 0x00000001,
                ATTRIBUTE_FOLDER        = 0x00000010,
                ATTRIBUTE_HIDDEN        = 0x00000002,
                ATTRIBUTE_SYSTEM        = 0x00000004,
                ATTRIBUTE_ARCHIVE       = 0x00000020,
                ATTRIBUTE_COMPRESSED    = 0x00000800,
                ATTRIBUTE_ENCRYPTED     = 0x00004000,
                ATTRIBUTE_OFFLINE       = 0x00001000,
            #else
                ATTRIBUTE_READONLY      = 1,
                ATTRIBUTE_FOLDER        = 2,
                ATTRIBUTE_HIDDEN        = 4,
                ATTRIBUTE_SYSTEM        = 8,
                ATTRIBUTE_ARCHIVE       = 16,
                ATTRIBUTE_COMPRESSED    = 32,
                ATTRIBUTE_ENCRYPTED     = 64,
                ATTRIBUTE_OFFLINE       = 128,
            #endif
            ATTRIBUTE_SYMLINK           = 256,
            ATTRIBUTE_PIPE              = 512,
            ATTRIBUTE_BLOCKDEVICE       = 1024,
            ATTRIBUTE_CHARDEVICE        = 2048,
            ATTRIBUTE_INVALID           = 0xFFFFFFFF
        } FileAttributeFlag;
 
        cFileAttributes()
        {
            Init();
        }
 
        cFileAttributes(tUInt32 nAttributes)
        {
            Set(nAttributes);
        }
 
        tBool Set(tUInt32 nAttributes)
        {
            if (nAttributes != ATTRIBUTE_INVALID)
            {
                bValid          = true;
                bReadOnly       = ((nAttributes & ATTRIBUTE_READONLY)       != 0);
                bFolder         = ((nAttributes & ATTRIBUTE_FOLDER)         != 0);
                bHidden         = ((nAttributes & ATTRIBUTE_HIDDEN)         != 0);
                bSystem         = ((nAttributes & ATTRIBUTE_SYSTEM)         != 0);
                bArchive        = ((nAttributes & ATTRIBUTE_ARCHIVE)        != 0);
                bCompressed     = ((nAttributes & ATTRIBUTE_COMPRESSED)     != 0);
                bEncrypted      = ((nAttributes & ATTRIBUTE_ENCRYPTED)      != 0);
                bOffline        = ((nAttributes & ATTRIBUTE_OFFLINE)        != 0);
                bSymLink        = ((nAttributes & ATTRIBUTE_SYMLINK)        != 0);
                bPipe           = ((nAttributes & ATTRIBUTE_PIPE)           != 0);
                bBlockDevice    = ((nAttributes & ATTRIBUTE_BLOCKDEVICE)    != 0);
                bCharDevice     = ((nAttributes & ATTRIBUTE_CHARDEVICE)     != 0);
 
                return true;
            }
            else
            {
                Init();
 
                return false;
            }
        }
 
        tUInt32 GetAttributes(tUInt32& nAttributes) const
        {
            if (bValid)
            {
                nAttributes = 0;
 
                if (bReadOnly)
                    nAttributes |= ATTRIBUTE_READONLY;
                if (bFolder)
                    nAttributes |= ATTRIBUTE_FOLDER;
                if (bHidden)
                    nAttributes |= ATTRIBUTE_HIDDEN;
                if (bSystem)
                    nAttributes |= ATTRIBUTE_SYSTEM;
                if (bArchive)
                    nAttributes |= ATTRIBUTE_ARCHIVE;
                if (bCompressed)
                    nAttributes |= ATTRIBUTE_COMPRESSED;
                if (bEncrypted)
                    nAttributes |= ATTRIBUTE_ENCRYPTED;
                if (bOffline)
                    nAttributes |= ATTRIBUTE_OFFLINE;
                if (bSymLink)
                    nAttributes |= ATTRIBUTE_SYMLINK;
                if (bPipe)
                    nAttributes |= ATTRIBUTE_PIPE;
                if (bBlockDevice)
                    nAttributes |= ATTRIBUTE_BLOCKDEVICE;
                if (bCharDevice)
                    nAttributes |= ATTRIBUTE_CHARDEVICE;
 
                return nAttributes;
            }
            else
            {
                return (tUInt32)ATTRIBUTE_INVALID;
            }
        }
 
    private:
        void Init()
        {
            bValid          = false;
            bReadOnly       = false;
            bFolder         = false;
            bHidden         = false;
            bSystem         = false;
            bArchive        = false;
            bCompressed     = false;
            bEncrypted      = false;
            bOffline        = false;
            bSymLink        = false;
            bPipe           = false;
            bBlockDevice    = false;
            bCharDevice     = false;
        }
};
 
class DOEXPORT cFileSystem
{
    public:
        enum
        {
            ED_DEFAULT      = 0x0,
            ED_FILES        = 0x1,
            ED_DIRECTORIES  = 0x2
        };
 
        typedef enum
        {
            PERM_USR_RD = 0x0400,
            PERM_USR_WR = 0x0200,
            PERM_USR_EX = 0x0100,
 
            PERM_GRP_RD = 0x0040,
            PERM_GRP_WR = 0x0020,
            PERM_GRP_EX = 0x0010,
 
            PERM_OTH_RD = 0x0004,
            PERM_OTH_WR = 0x0002,
            PERM_OTH_EX = 0x0001,
 
            PERM_SUID = 0x4000,
            PERM_SGID = 0x2000,
            PERM_SVTX = 0x1000
        } FilePermissionFlag;
 
 
    protected:
        static cFilename m_strLastBrowseDir;        
        static tUInt32   m_ui32DefaultSectorSize;   
 
    public:
 
        static tUInt32 GetFileAttrib(const cFilename& strFilename);
 
        static tResult ReadTextFile(const cFilename& strFilename, 
                                    cString& strString,
                                    const tUInt32& ui32OpenMode=cFile::OM_Read |
                                                                cFile::OM_SharedRead |
                                                                cFile::OM_SequentialAccess);
 
        static tResult WriteTextFile(const cFilename& strFilename, const cString& strString);
 
        static tBool Exists(const cFilename& strFilename);
 
        static tFileSize GetFileSize(const cFilename& strFilename);
 
        static tBool IsFile(const cFilename& strFilename);
 
        static tBool IsDirectory(const cFilename& strFilename);
 
        static tResult CreatePath(const cFilename& strDirName, tBool bRecursive = false);
 
        static tBool IsReadOnly(const cFilename& strFilename);
 
        static tResult SetReadOnly(const cFilename& strFilename, tBool bReadOnly = true);
 
        static tResult DelFile(const cFilename& strFilename);
 
        static tResult DelDirectory(const cFilename& strDirectory);
 
        static cFilename GetCurDirectory();
 
        static tResult SetCurDirectory(const cFilename& strDirName);
 
        static cFilename GetAppDirectory();
#ifdef WIN32
        static cFilename GetWinDirectory();
#endif
        static cFilename GetSysDirectory();
 
        static cFilename GetOwnModuleFileName();
 
        static cFilename GetOwnModuleDirectory();
        static cFilename GetUserApplicationDirectory(const cString& strApplication=cString::Empty);
        static cFilename GetTempDirectory();
        static tResult FileCopy(const cString &strFrom,const cString &strTo);
 
        static tResult FolderCopy(const cFilename &strFrom,const cFilename &strTo);
 
        static tResult Move(const cFilename &strFrom,const cFilename &strTo);
        
        static tUInt32 GetFilePermissions(const cFilename& strFilename);
 
        static tResult SetFilePermissions(const cFilename& strFilename, tUInt32 nPermissionMask);
        static tInt GetDefaultSectorSize();
        static tInt GetSectorSize(const cFilename& strFilename);
        static tVoid* AllocPageAlignedMemory(tInt nSize, tInt nPageSize=0);
        static tResult FreePageAlignedMemory(tVoid* pMemory);
        
        static tResult EnumDirectory(const cFilename& strDir,
                                     cStringList& lstFiles,
                                     tUInt32 ui32Flags=0);
        static tResult GetFreeDiskSpace(const tChar* strFolder, tUInt64 *pui64FreeBytes);
       
        static tResult FindFiles(const cString & strPattern, cStringList & lstFiles);
 
        static tResult FindFolders(const cString& strPattern, cStringList& lstFolders);
 
        static tResult GetTimeAccess(const cFilename filename, A_UTILS_NS::cDateTime &dt);
 
        static tResult GetTimeCreation(const cFilename filename, A_UTILS_NS::cDateTime &dt);
 
        static tResult GetTimeChange(const cFilename filename, A_UTILS_NS::cDateTime &dt);
 
        static tInt GetLastErrorCode();
 
         static tResult RenameFilename(cFilename oldFileName, cFilename newFileName);
};
 
} // namespace A_UTILS_NS
 
#endif // _FILE_CLASS_HEADER_