cManifestDir.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cManifestDir_h
#define _INC_cManifestDir_h
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../Hash/cCRC.h"
#include "GrayCore/include/cString.h"
#include "GrayCore/include/cFileDir.h"
#include "GrayCore/include/cFilePath.h"
#include "GrayCore/include/cLogMgr.h"
#include "GrayCore/include/cArraySortRef.h"
#include "GrayCore/include/cArraySortString.h"
#include "GrayCore/include/cIniSection.h"
 
namespace GrayLib
{
        class cManifestRoot;
        class cManifestBuilder;
 
        class GRAYLIB_LINK cManifestElemData
        {
 
        public:
                FILEATTR_MASK_t m_Attributes;   
                FILE_SIZE_t m_Size;                     
                cTimeInt m_timeChange;          
                CRC32_t m_CRC32;                        
                // TODO Secure Hash Code. More collision proof hash than CRC
 
        public:
                cManifestElemData(FILEATTR_MASK_t dwAttrMask = FILEATTR_None, FILE_SIZE_t Size = 0, cTimeInt timeChange = cTimeInt::k_nZero, CRC32_t CRC32 = cCRC32Table::k_nStart);
                cManifestElemData(const cFileStatus& rStatus, CRC32_t nCRC32 = 0);
                ~cManifestElemData();
 
                void InitData(FILEATTR_MASK_t Attributes = FILEATTR_None);
                void InitDataS(const cFileStatus& rStatus);
 
                bool IsAttrMask(FILEATTR_MASK_t dwAttrMask) const noexcept
                {
                        return((m_Attributes&dwAttrMask) ? true : false);
                }
                bool isAttrDir() const noexcept
                {
                        return IsAttrMask(FILEATTR_Directory);
                }
                bool isAttrHidden() const noexcept
                {
                        return IsAttrMask(FILEATTR_Hidden);
                }
 
                bool IsEqual(const cManifestElemData& Test) const;
                bool IsSameFileDataS(const cFileStatus& status) const;
                bool IsSameFileData(const cManifestElemData& Test) const;
        };
 
        class GRAYLIB_LINK cManifestElem
                : public cRefBase
        {
 
        public:
                cStringF m_sFileName;                   
                cManifestElemData m_ElemData;   
 
        public:
                cManifestElem(const cManifestElem& rCopy);
                cManifestElem(cStringF sFileName, const cManifestElemData& rData);
                virtual ~cManifestElem();
 
                static HRESULT GRAYCALL ParseLine(IniChar_t* pszLine, OUT cStringF& sFileName, OUT cManifestElemData& data);
 
                virtual cStringF get_Name() const noexcept
                {
                        return m_sFileName;
                }
        };
        typedef cRefPtr<cManifestElem> cManifestElemPtr;
 
        class GRAYLIB_LINK cManifestDir
        {
 
        public:
                enum MANTAG_TYPE
                {
#define cManifestDirProp(a,b,c) MANTAG_##a,
#include "cManifestDirProps.tbl"
#undef cManifestDirProp
                        MANTAG_QTY
                };
                static const IniChar_t* k_ManTags[MANTAG_QTY + 1];
                static const IniChar_t* k_pszSectionName;               
                cArraySortName<cManifestElem> m_aElems;                 
 
        protected:
                const cStringF m_sDirPath;              
                cManifestElemData m_ManData;    
 
        protected:
                HRESULT BuildManifestElem(cManifestBuilder& root, const cManifestDir* pManifestOld, cFileFindEntry& FileEntry);
                HRESULT BuildManifestMerge(cManifestBuilder& root, const cManifestDir* pManifestOld, FILEATTR_MASK_t dwAttributes);
 
        public:
                cManifestDir(cStringF sDirFullPath);
                cManifestDir(const cManifestRoot& root);
                virtual ~cManifestDir();
 
                const FILECHAR_t* get_Name() const
                {
                        return cFilePath::GetFileName(m_sDirPath);
                }
                cStringF get_DirPath() const noexcept
                {
                        return m_sDirPath;
                }
                cManifestElemData& ref_ElemData()
                {
                        return m_ManData;
                }
                CRC32_t get_ManCRC32() const
                {
                        return m_ManData.m_CRC32; 
                }
                bool HasChild(const cManifestDir& rManChild) const;
 
                HRESULT ReadManifestFile(cStringF sFullManifestPath);
                HRESULT ReadManifestFile(const cManifestRoot& root, const FILECHAR_t* pszManifestName = nullptr);
                HRESULT ReadSearchForTitle(const cManifestRoot& root, cStringF& sPathRet, const FILECHAR_t* pszTitle, int iDescendLevels);
 
                HRESULT WriteManifestSection(cStreamOutput& file);
                HRESULT WriteManifestFile(const cManifestRoot& root);
                HRESULT BuildManifest(cManifestBuilder& root, FILEATTR_MASK_t dwAttributes = FILEATTR_Directory);
 
                cStringF makeFilePath(const FILECHAR_t* pszFileName) const
                {
                        return cFilePath::CombineFilePathX(m_sDirPath, pszFileName);
                }
 
                ITERATE_t addManifestElem(cManifestElem* pData);
                bool rebuildManifestData();
        };
 
        class GRAYLIB_LINK cManifestRoot
        {
 
        public:
                static const FILECHAR_t* k_pszManifestDefault;  
                const FILECHAR_t* m_pszManifestFileName;                
 
        protected:
                cStringF m_sRootDir;            
 
        public:
                cManifestRoot(cStringF sRootDir, const FILECHAR_t* pszManifestFileName = nullptr);
                ~cManifestRoot();
 
                cStringF get_RootDir() const
                {
                        return m_sRootDir;
                }
                void put_RootDir(cStringF sRootDir)
                {
                        m_sRootDir = sRootDir;
                }
 
                bool isRootDir(const FILECHAR_t* pszDirPath) const
                {
                        return !m_sRootDir.CompareNoCase(pszDirPath);
                }
                bool isInRootPath(const FILECHAR_t* pszDirPath) const
                {
                        return cFilePath::IsRelativeRoot(pszDirPath, get_RootDir());
                }
                cStringF makeFullPath(const FILECHAR_t* pszRelativePath) const
                {
                        return cFilePath::CombineFilePathX(get_RootDir(), pszRelativePath);
                }
                cStringF makeRelativePath(const FILECHAR_t* pszDirPath) const
                {
                        return cFilePath::MakeRelativePath(pszDirPath, get_RootDir());
                }
 
                HRESULT ReadSearchForTitle(cStringF& sPathRet, const FILECHAR_t* pszTitle, int iDescendLevels) const;
        };
 
        class GRAYLIB_LINK cManifestContext : public cManifestRoot
        {
 
        public:
                // callbacks for progress
                cLogProcessor* m_pLog;                                  
                IStreamProgressCallback* m_pProgress;   
 
        public:
                cManifestContext(cStringF sDirRoot, const FILECHAR_t* pszManifestFileName = nullptr, cLogProcessor* pLog = nullptr, IStreamProgressCallback* pProgress = nullptr);
                ~cManifestContext();
 
                HRESULT UpdateProgress(const cStreamProgress& s)
                {
                        if (m_pProgress == nullptr)     // ignore this.
                                return S_OK;
                        return m_pProgress->onProgressCallback(s);
                }
        };
 
        class GRAYLIB_LINK cManifestBuilder
        {
 
                friend class cManifestDir;
 
        public:
                cManifestContext& m_Context;    
 
                bool m_bTrustCRC;               
                cArraySortString<FILECHAR_t>* m_pChangeList;    
                int m_iChanges;                                                 
 
        protected:
                cStreamProgressF m_ManProgress;                 
 
        protected:
                bool isTrustedDir(const FILECHAR_t* pszDirPath) const;
 
                virtual HRESULT onFilePrep(cManifestDir* pManLocal, cFileFindEntry& FileEntry, cManifestElem* pElementOld);     // callback when file is about to be checked.
                virtual HRESULT onDirComplete(cManifestDir* pManLocal, HRESULT hRes);   // callback when dir manifest is verified/computed.
                virtual HRESULT onChangeManifest(cManifestDir* pManLocal, const FILECHAR_t* pszElemName);
 
        public:
                cManifestBuilder(cManifestContext& context);
                virtual ~cManifestBuilder();
 
                HRESULT DoBuildManifest(const FILECHAR_t* pszRelativePath = nullptr);
 
                UNITTEST_FRIEND(cManifestDir);
        };
}
 
#endif