cFileStatus.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_CFileStatus_H
#define _INC_CFileStatus_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "FileName.h"
#include "cTimeFile.h"
#include "cTimeInt.h"
#include "cValT.h"
#include "cStreamProgress.h"
#include "HResult.h"
 
#ifdef _WIN32
typedef WIN32_FIND_DATAW cFileStatusSys;        // or BY_HANDLE_FILE_INFORMATION ?
#else
struct stat;
typedef struct stat cFileStatusSys;             // from stat(), lstat() or fstat() 
#endif
 
namespace Gray
{
#ifdef _WIN32
        typedef ULONGLONG FILE_SIZE_t;  
#else
        typedef UINT64 FILE_SIZE_t;     
#endif
 
        enum FILEATTR_TYPE_
        {
                FILEATTR_None,
                FILEATTR_ReadOnly = 0x0001,     
                FILEATTR_Hidden = 0x0002,       
                FILEATTR_System = 0x0004,       
 
                FILEATTR_NormalMask = 0x000F,   
 
                FILEATTR_Directory = 0x0010,    
                FILEATTR_Archive = 0x0020,      
                FILEATTR_Volume = 0x0040,       
                FILEATTR_Normal = 0x0080,       
 
                // NTFS only flags. (maybe Linux)
                FILEATTR_Temporary = 0x0100,    
                FILEATTR_Link = 0x0400,                 
                FILEATTR_Compress = 0x0800,             
        };
        typedef UINT32 FILEATTR_MASK_t; // FILEATTR_TYPE_ mask
 
        class GRAYCORE_LINK cFileStatus
        {
 
                typedef cFileStatus THIS_t;
 
        public:
                cTimeFile m_timeCreate;         
                cTimeFile m_timeChange;         
                cTimeFile m_timeLastAccess;     
                FILE_SIZE_t m_Size;                     
                FILEATTR_MASK_t m_Attributes;           
 
        public:
                cFileStatus();
                cFileStatus(const FILECHAR_t* pszFilePath);
 
                void InitFileStatus();
                void InitFileStatus(const cFileStatusSys& statusSys);
 
#if defined(__linux__)
                static HRESULT GRAYCALL GetStatusSys(OUT cFileStatusSys& statusSys, const FILECHAR_t* pszName, bool bFollowLinks = false);
#endif
 
                static bool IsLinuxHidden(const FILECHAR_t* pszName) noexcept
                {
                        if (pszName == nullptr)
                                return true;
                        return pszName[0] == '.';
                }
                bool UpdateLinuxHidden(const FILECHAR_t* pszName) noexcept
                {
                        if (IsLinuxHidden(pszName))
                        {
                                m_Attributes |= FILEATTR_Hidden;
                                return true;
                        }
                        return false;
                }
 
                bool isFileValid() const noexcept
                {
                        return m_timeChange.isValid();
                }
 
                static COMPARE_t GRAYCALL CompareChangeFileTime(const cTimeFile& t1, const cTimeFile& t2)       
                {
                        return cValT::Compare(t1.get_FAT32(), t2.get_FAT32());
                }
                bool IsSameChangeFileTime(const cTimeFile& t2) const noexcept   
                {
                        return cValT::Compare(m_timeChange.get_FAT32(), t2.get_FAT32()) == COMPARE_Equal;
                }
                static TIMESEC_t GRAYCALL MakeFatTime(TIMESEC_t tTime) noexcept
                {
                        return tTime & ~1;
                }
                static COMPARE_t GRAYCALL CompareChangeTime(const cTimeInt& t1, const cTimeInt& t2) noexcept
                {
                        return cValT::Compare(MakeFatTime(t1.GetTime()), MakeFatTime(t2.GetTime()));
                }
                bool IsSameChangeTime(const cTimeInt& t2) const noexcept
                {
                        return CompareChangeTime(m_timeChange, t2) == COMPARE_Equal;
                }
 
                bool IsFileEqualTo(const THIS_t& rFileStatus) const noexcept
                {
                        if (cValT::Compare(m_timeCreate.get_Val(), rFileStatus.m_timeCreate.get_Val()) != COMPARE_Equal)
                                return false;
                        if (!IsSameChangeFileTime(rFileStatus.m_timeChange))
                                return false;
                        if (m_Size != rFileStatus.m_Size)
                                return false;
                        return true;
                }
                bool IsFileEqualTo(const THIS_t* pFileStatus) const noexcept
                {
                        if (pFileStatus == nullptr)
                                return false;
                        return IsFileEqualTo(*pFileStatus);
                }
                bool IsAttrMask(FILEATTR_MASK_t dwAttrMask = FILEATTR_ReadOnly) const noexcept
                {
                        return(m_Attributes & dwAttrMask) ? true : false;
                }
                bool isAttrDir() const noexcept
                {
                        return IsAttrMask(FILEATTR_Directory);
                }
                bool isAttrHidden() const noexcept
                {
                        // for __linux__ starts with .
                        return IsAttrMask(FILEATTR_Hidden);
                }
                FILE_SIZE_t GetFileLength() const noexcept
                {
                        return m_Size;
                }
 
                static HRESULT GRAYCALL WriteFileAttributes(const FILECHAR_t* pszFilePath, FILEATTR_MASK_t dwAttributes);
                static HRESULT GRAYCALL WriteFileTimes(const FILECHAR_t* pszFilePath, const cTimeFile* pTimeCreate, const cTimeFile* pTimeChange = nullptr);
                static HRESULT GRAYCALL WriteFileTimes(const FILECHAR_t* pszFilePath, const cFileStatus& rFileStatus);
                static HRESULT GRAYCALL ReadFileStatus2(const FILECHAR_t* pszFilePath, cFileStatus* pFileStatus = nullptr, bool bFollowLink = false);
 
                static bool GRAYCALL Exists(const FILECHAR_t* pszFilePath)
                {
                        HRESULT hRes = ReadFileStatus2(pszFilePath, nullptr, true);
                        return SUCCEEDED(hRes);
                }
 
                HRESULT ReadFileStatus(const FILECHAR_t* pszFilePath, bool bFollowLink = false)
                {
                        return ReadFileStatus2(pszFilePath, this, bFollowLink);
                }
        };
}
 
#endif