react-native-update 10.34.1 → 10.34.3

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_diff/dir_diff.h

@@ -0,0 +1,79 @@
+// dir_diff.h
+// hdiffz dir diff
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2018-2019 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef hdiff_dir_diff_h
+#define hdiff_dir_diff_h
+#include "../dir_patch/dir_patch_types.h"
+
+struct THDiffSets{
+    hpatch_BOOL isDiffInMem;//or diff by stream
+    hpatch_BOOL isSingleCompressedDiff;
+    //diff in mem
+    hpatch_BOOL isUseBigCacheMatch;
+    hpatch_BOOL isCheckNotEqual;
+    size_t matchScore;
+    size_t patchStepMemSize;
+    size_t matchBlockSize;
+    size_t threadNum;
+    size_t threadNumSearch_s;
+};
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#include "dir_manifest.h"
+
+
+struct IDirDiffListener{
+    virtual ~IDirDiffListener(){}
+    virtual bool isExecuteFile(const std::string& fileName) { return false; }
+    virtual void diffRefInfo(size_t oldPathCount,size_t newPathCount,size_t sameFilePairCount,
+                             hpatch_StreamPos_t sameFileSize,size_t refOldFileCount,size_t refNewFileCount,
+                             hpatch_StreamPos_t refOldFileSize,hpatch_StreamPos_t refNewFileSize){}
+    virtual void runHDiffBegin(){}
+    virtual void runHDiffEnd(hpatch_StreamPos_t diffDataSize){}
+    virtual void externData(std::vector<unsigned char>& out_externData){}
+    virtual void externDataPosInDiffStream(hpatch_StreamPos_t externDataPos,size_t externDataSize){}
+};
+
+void dir_diff(IDirDiffListener* listener,const TManifest& oldManifest,
+              const TManifest& newManifest,const hpatch_TStreamOutput* outDiffStream,
+              const hdiff_TCompress* compressPlugin,hpatch_TChecksum* checksumPlugin,
+              const THDiffSets& hdiffSets,size_t kMaxOpenFileNumber);
+bool check_dirdiff(IDirDiffListener* listener,const TManifest& oldManifest,const TManifest& newManifest,
+                   const hpatch_TStreamInput* testDiffData,hpatch_TDecompress* decompressPlugin,
+                   hpatch_TChecksum* checksumPlugin,size_t kMaxOpenFileNumber,size_t threadNum=1);
+
+//check oldPath's data is same as that in dir_diff
+hpatch_BOOL check_dirOldDataChecksum(const char* oldPath,hpatch_TStreamInput* diffData,
+                                     hpatch_TDecompress* decompressPlugin,hpatch_TChecksum* checksumPlugin);
+
+void resave_dirdiff(const hpatch_TStreamInput* in_diff,hpatch_TDecompress* decompressPlugin,
+                    const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin,
+                    hpatch_TChecksum* checksumPlugin);
+
+#endif
+#endif //hdiff_dir_diff_h

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_diff/dir_diff_tools.cpp

@@ -0,0 +1,339 @@
+// dir_diff_tools.cpp
+// hdiffz dir diff
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2018-2019 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "dir_diff_tools.h"
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#ifdef _WIN32
+#   include <windows.h> //FindFirstFileW ...
+#else
+#   include <dirent.h> //opendir ...
+#endif
+
+#ifdef _WIN32
+
+    struct _hdiff_TFindFileData{
+        HANDLE              handle;
+        char                subName_utf8[hpatch_kPathMaxSize];
+    };
+
+hdiff_TDirHandle hdiff_dirOpenForRead(const char* dir_utf8){
+    size_t      ucSize=strlen(dir_utf8);
+    hpatch_BOOL isNeedDirSeparator=(ucSize>0)&&(dir_utf8[ucSize-1]!=kPatch_dirSeparator);
+    wchar_t     dir_w[hpatch_kPathMaxSize];
+    int wsize=_utf8FileName_to_w(dir_utf8,dir_w,hpatch_kPathMaxSize-3);
+    if (wsize<=0) return 0; //error
+    if (dir_w[wsize-1]=='\0') --wsize;
+    if (isNeedDirSeparator)
+        dir_w[wsize++]=kPatch_dirSeparator;
+    dir_w[wsize++]='*';
+    dir_w[wsize++]='\0';
+    _hdiff_TFindFileData*  finder=(_hdiff_TFindFileData*)malloc(sizeof(_hdiff_TFindFileData));
+    WIN32_FIND_DATAW findData;
+    finder->handle=FindFirstFileW(dir_w,&findData);
+    if (finder->handle!=INVALID_HANDLE_VALUE){
+        return finder; //open dir ok
+    }else{
+        DWORD errcode = GetLastError();
+        if (errcode==ERROR_FILE_NOT_FOUND) {
+            return finder; //open dir ok
+        }else{
+            free(finder);
+            return 0; //error
+        }
+    }
+}
+
+hpatch_BOOL hdiff_dirNext(hdiff_TDirHandle dirHandle,hpatch_TPathType *out_type,const char** out_subName_utf8){
+    assert(dirHandle!=0);
+    _hdiff_TFindFileData* finder=(_hdiff_TFindFileData*)dirHandle;
+    if (finder->handle==INVALID_HANDLE_VALUE) { *out_subName_utf8=0; return hpatch_TRUE; }//finish
+    WIN32_FIND_DATAW findData;
+    if (!FindNextFileW(finder->handle,&findData)){
+        DWORD errcode = GetLastError();
+        if (errcode==ERROR_NO_MORE_FILES) { *out_subName_utf8=0; return hpatch_TRUE; }//finish
+        return hpatch_FALSE; //error
+    }
+    //get name
+    const wchar_t* subName_w=(const wchar_t*)findData.cFileName;
+    int bsize=_wFileName_to_utf8(subName_w,finder->subName_utf8,hpatch_kPathMaxSize);
+    if (bsize<=0) return hpatch_FALSE; //error
+    *out_subName_utf8=finder->subName_utf8;
+    //get type
+    if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY){
+        *out_type=kPathType_dir;
+    }else{
+        *out_type=kPathType_file;
+    }
+    return hpatch_TRUE;
+}
+
+void hdiff_dirClose(hdiff_TDirHandle dirHandle){
+    _hdiff_TFindFileData* finder=(_hdiff_TFindFileData*)dirHandle;
+    if (finder!=0){
+        if (finder->handle!=INVALID_HANDLE_VALUE)
+            FindClose(finder->handle);
+        free(finder);
+    }
+}
+
+#else  // _WIN32
+
+hdiff_TDirHandle hdiff_dirOpenForRead(const char* dir_utf8){
+    hdiff_TDirHandle h=opendir(dir_utf8);
+    if (!h) return 0; //error
+    return h;
+}
+
+hpatch_BOOL hdiff_dirNext(hdiff_TDirHandle dirHandle,hpatch_TPathType *out_type,const char** out_subName_utf8){
+    assert(dirHandle!=0);
+    DIR* pdir =(DIR*)dirHandle;
+    struct dirent* pdirent = readdir(pdir);
+    if (pdirent==0){
+        *out_subName_utf8=0; //finish
+        return hpatch_TRUE;
+    }
+    
+    if (pdirent->d_type==DT_DIR){
+        *out_type=kPathType_dir;
+        *out_subName_utf8=pdirent->d_name;
+        return hpatch_TRUE;
+    }else if (pdirent->d_type==DT_REG){
+        *out_type=kPathType_file;
+        *out_subName_utf8=pdirent->d_name;
+        return hpatch_TRUE;
+    }else{
+        return hdiff_dirNext(dirHandle,out_type,out_subName_utf8);
+    }
+}
+
+void hdiff_dirClose(hdiff_TDirHandle dirHandle){
+    if (dirHandle)
+        closedir((DIR*)dirHandle);
+}
+
+#endif // if _WIN32 else
+#endif // _IS_NEED_DIR_DIFF_PATCH
+
+
+namespace hdiff_private{
+
+    hpatch_StreamPos_t getFileSize(const std::string& fileName){
+        hpatch_StreamPos_t fileSize;
+        checkv(hpatch_getFileSize(fileName.c_str(),&fileSize));
+        return fileSize;
+    }
+    
+    
+    void CChecksum::append(const hpatch_TStreamInput* data,hpatch_StreamPos_t begin,hpatch_StreamPos_t end){
+        if (!_handle) return;
+        TAutoMem buf(hdiff_kFileIOBufBestSize);
+        while (begin<end){
+            size_t len=buf.size();
+            if (len>(end-begin))
+                len=(size_t)(end-begin);
+            checkv(data->read(data,begin,buf.data(),buf.data()+len));
+            append(buf.data(),buf.data()+len);
+            begin+=len;
+        }
+    }
+    
+    void pushTypes(std::vector<TByte>& out_data,const char* kTypeAndVersion,
+                   const char* compressPluginType,hpatch_TChecksum* checksumPlugin){
+        //type version
+        pushCStr(out_data,kTypeAndVersion);
+        pushCStr(out_data,"&");
+        {//compressType
+            const char* compressType="";
+            if (compressPluginType)
+                compressType=compressPluginType;
+            size_t compressTypeLen=strlen(compressType);
+            check(compressTypeLen<=hpatch_kMaxPluginTypeLength,"compressTypeLen error!");
+            check(0==strchr(compressType,'&'), "compressType cannot contain '&'");
+            pushCStr(out_data,compressType);
+        }
+        pushCStr(out_data,"&");
+        {//checksumType
+            const char* checksumType="";
+            if (checksumPlugin)
+                checksumType=checksumPlugin->checksumType();
+            size_t checksumTypeLen=strlen(checksumType);
+            check(checksumTypeLen<=hpatch_kMaxPluginTypeLength,"checksumTypeLen error!");
+            check(0==strchr(checksumType,'&'), "checksumType cannot contain '&'");
+            pushCStr(out_data,checksumType);
+        }
+        const TByte _cstrEndTag='\0';//c string end tag
+        pushBack(out_data,&_cstrEndTag,(&_cstrEndTag)+1);
+    }
+    
+#if (_IS_NEED_DIR_DIFF_PATCH)
+    
+    static const std::string _kBufResName="";
+
+    TOffsetStreamOutput::TOffsetStreamOutput(const hpatch_TStreamOutput* base,hpatch_StreamPos_t offset)
+    :_base(base),_offset(offset),outSize(0){
+        assert(offset<=base->streamSize);
+        this->streamImport=this;
+        this->streamSize=base->streamSize-offset;
+        this->read_writed=0;
+        this->write=_write;
+    }
+    hpatch_BOOL TOffsetStreamOutput::_write(const hpatch_TStreamOutput* stream,const hpatch_StreamPos_t writeToPos,
+                                            const unsigned char* data,const unsigned char* data_end){
+        TOffsetStreamOutput* self=(TOffsetStreamOutput*)stream->streamImport;
+        hpatch_StreamPos_t newSize=writeToPos+(data_end-data);
+        if (newSize>self->outSize) self->outSize=newSize;
+        return self->_base->write(self->_base,self->_offset+writeToPos,data,data_end);
+    }
+
+    void CRefStream::open(const hpatch_TStreamInput** refList,size_t refCount,size_t kAlignSize){
+        check(hpatch_TRefStream_open(this,refList,refCount,kAlignSize),"TRefStream_open() refList error!");
+    }
+    void packIncList(std::vector<TByte>& out_data,const size_t* list,size_t listSize){
+        size_t backValue=~(size_t)0;
+        for (size_t i=0;i<listSize;++i){
+            size_t curValue=list[i];
+            assert(curValue>=(size_t)(backValue+1));
+            packUInt(out_data,(size_t)(curValue-(size_t)(backValue+1)));
+            backValue=curValue;
+        }
+    }
+    
+    void packList(std::vector<TByte>& out_data,const hpatch_StreamPos_t* list,size_t listSize){
+        for (size_t i=0;i<listSize;++i){
+            packUInt(out_data,list[i]);
+        }
+    }
+    
+    
+    static void formatDirTagForSave(std::string& path_utf8){
+        if (kPatch_dirSeparator==kPatch_dirSeparator_saved) return;
+        for (size_t i=0;i<path_utf8.size();++i){
+            if (path_utf8[i]!=kPatch_dirSeparator)
+                continue;
+            else
+                path_utf8[i]=kPatch_dirSeparator_saved;
+        }
+    }
+    
+    size_t pushNameList(std::vector<TByte>& out_data,const char* rootPath,
+                        const std::string* nameList,size_t nameListSize){
+        const size_t rootLen=strlen(rootPath);
+        std::string utf8;
+        size_t outSize=0;
+        for (size_t i=0;i<nameListSize;++i){
+            const std::string& name=nameList[i];
+            const size_t nameSize=name.size();
+            assert(nameSize>=rootLen);
+            assert(0==memcmp(name.data(),rootPath,rootLen));
+            const char* subName=name.c_str()+rootLen;
+            const char* subNameEnd=subName+(nameSize-rootLen);
+            utf8.assign(subName,subNameEnd);
+            formatDirTagForSave(utf8);
+            size_t writeLen=utf8.size()+1; // '\0'
+            out_data.insert(out_data.end(),utf8.c_str(),utf8.c_str()+writeLen);
+            outSize+=writeLen;
+        }
+        return outSize;
+    }
+
+    
+    CFileResHandleLimit::CFileResHandleLimit(size_t _limitMaxOpenCount,size_t resCount)
+    :limitMaxOpenCount(_limitMaxOpenCount),curInsert(0),bufRes(0),bufResSize(0){
+        hpatch_TResHandleLimit_init(&limit);
+        resList.resize(resCount);
+        memset(resList.data(),0,sizeof(hpatch_IResHandle)*resCount);
+        fileList.resize(resCount);
+        for(size_t i=0;i<resCount;++i)
+            hpatch_TFileStreamInput_init(&fileList[i]);
+    }
+    
+    void CFileResHandleLimit::addBufRes(const hpatch_byte* _bufRes,size_t _bufResSize){
+        checkv(bufResSize==0);
+        checkv((_bufRes!=0)&&(_bufResSize>0));
+        bufRes=_bufRes;
+        bufResSize=_bufResSize;
+        _addRes(_kBufResName,_bufResSize);
+    }
+    void CFileResHandleLimit::addRes(const std::string& fileName,hpatch_StreamPos_t fileSize){
+        checkv(fileName!=_kBufResName);
+        _addRes(fileName,fileSize);
+    }
+    void CFileResHandleLimit::_addRes(const std::string& fileName,hpatch_StreamPos_t fileSize){
+        assert(curInsert<resList.size());
+        fileList[curInsert].fileName=fileName;
+        fileList[curInsert].owner=this;
+        hpatch_IResHandle* res=&resList[curInsert];
+        res->open=CFileResHandleLimit::openRes;
+        res->close=CFileResHandleLimit::closeRes;
+        res->resImport=&fileList[curInsert];
+        res->resStreamSize=fileSize;
+        ++curInsert;
+    }
+    void CFileResHandleLimit::open(){
+        assert(curInsert==resList.size());
+        check(hpatch_TResHandleLimit_open(&limit,limitMaxOpenCount,resList.data(),
+                                          resList.size()),"TResHandleLimit_open error!");
+    }
+    bool CFileResHandleLimit::closeFileHandles(){
+        return hpatch_TResHandleLimit_closeFileHandles(&limit)!=0;
+    }
+    void CFileResHandleLimit::close(){
+        check(hpatch_TResHandleLimit_close(&limit),"TResHandleLimit_close error!");
+    }
+    
+    hpatch_BOOL CFileResHandleLimit::openRes(struct hpatch_IResHandle* res,hpatch_TStreamInput** out_stream){
+        CFile* self=(CFile*)res->resImport;
+        assert(self->m_file==0);
+        assert(self->owner!=0);
+        if (self->fileName==_kBufResName){
+            self->m_file=(hpatch_FileHandle)(~(size_t)0); //only for check safe
+            mem_as_hStreamInput(&self->base,self->owner->bufRes,
+                                self->owner->bufRes+self->owner->bufResSize);
+        }else{
+            check(hpatch_TFileStreamInput_open(self,self->fileName.c_str()),"CFileResHandleLimit open file error!");
+        }
+        *out_stream=&self->base;
+        return hpatch_TRUE;
+    }
+    hpatch_BOOL CFileResHandleLimit::closeRes(struct hpatch_IResHandle* res,const hpatch_TStreamInput* stream){
+        CFile* self=(CFile*)res->resImport;
+        assert(stream==&self->base);
+        assert(self->owner!=0);
+        if (self->fileName==_kBufResName){
+            assert(self->m_file==(hpatch_FileHandle)(~(size_t)0));
+            self->m_file=0;
+            memset(&self->base,0,sizeof(self->base));
+        }else{
+            check(hpatch_TFileStreamInput_close(self),"CFileResHandleLimit close file error!");
+        }
+        return hpatch_TRUE;
+    }
+
+#endif
+}

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_diff/dir_diff_tools.h

@@ -0,0 +1,190 @@
+// dir_diff_tools.h
+// hdiffz dir diff
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2018-2019 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef hdiff_dir_diff_tools_h
+#define hdiff_dir_diff_tools_h
+#include "dir_diff.h"
+#include <algorithm> //sort
+#include <string>
+#include "../../libHDiffPatch/HDiff/private_diff/pack_uint.h"
+#include "../../libHDiffPatch/HDiff/private_diff/mem_buf.h"
+#include "../../libHDiffPatch/HPatch/checksum_plugin.h"
+#include "../../libHDiffPatch/HDiff/diff_types.h"
+#include "../../file_for_patch.h"
+
+#define check(value,info) do { if (!(value)) { throw std::runtime_error(info); } } while(0)
+#define checkv(value)     do { check(value,"check "#value" error!"); } while(0)
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#include "../dir_patch/ref_stream.h"
+#include "../dir_patch/res_handle_limit.h"
+#include "file_for_dirDiff.h"
+#endif
+
+namespace hdiff_private{
+
+template <class TVector>
+static inline void swapClear(TVector& v){ TVector _t; v.swap(_t); }
+
+static inline bool isDirName(const std::string& path_utf8){
+    return 0!=hpatch_getIsDirName(path_utf8.c_str());
+}
+
+hpatch_StreamPos_t getFileSize(const std::string& fileName);
+
+inline static void writeStream(const hpatch_TStreamOutput* out_stream,hpatch_StreamPos_t& outPos,
+                               const TByte* buf_begin,const TByte* buf_end){
+    checkv(out_stream->write(out_stream,outPos,buf_begin,buf_end));
+    outPos+=(size_t)(buf_end-buf_begin);
+}
+inline static void writeStream(const hpatch_TStreamOutput* out_stream,hpatch_StreamPos_t& outPos,
+                               const TByte* buf,size_t byteSize){
+    writeStream(out_stream,outPos,buf,buf+byteSize);
+}
+inline static void writeStream(const hpatch_TStreamOutput* out_stream,hpatch_StreamPos_t& outPos,
+                               const std::vector<TByte>& buf){
+    if (!buf.empty())
+        writeStream(out_stream,outPos,&buf[0],&buf[0]+buf.size());
+}
+
+struct CFileStreamInput:public hpatch_TFileStreamInput{
+    inline CFileStreamInput(){ hpatch_TFileStreamInput_init(this); }
+    inline void open(const std::string& fileName){
+        assert(this->base.streamImport==0);
+        check(hpatch_TFileStreamInput_open(this,fileName.c_str()),"open file \""+fileName+"\" error!"); }
+    inline CFileStreamInput(const std::string& fileName){
+        hpatch_TFileStreamInput_init(this); open(fileName); }
+    inline void closeFile() { check(hpatch_TFileStreamInput_close(this),"close file error!"); }
+    inline ~CFileStreamInput(){ closeFile(); }
+};
+
+struct CFileStreamOutput:public hpatch_TFileStreamOutput{
+    inline CFileStreamOutput(){ hpatch_TFileStreamOutput_init(this); }
+    inline void open(const std::string& fileName,hpatch_StreamPos_t max_file_length){
+        assert(this->base.streamImport==0);
+        check(hpatch_TFileStreamOutput_open(this,fileName.c_str(),max_file_length),
+              "write file \""+fileName+"\" error!"); }
+    inline CFileStreamOutput(const std::string& fileName,hpatch_StreamPos_t max_file_length){
+        hpatch_TFileStreamOutput_init(this); open(fileName,max_file_length); }
+    inline void closeFile() { check(hpatch_TFileStreamOutput_close(this),"close file error!"); }
+    inline ~CFileStreamOutput(){ closeFile(); }
+};
+
+struct CChecksum{
+    inline explicit CChecksum():_checksumPlugin(0),_handle(0){}
+    inline explicit CChecksum(hpatch_TChecksum* checksumPlugin,bool autoBegin=true)
+    :_checksumPlugin(0),_handle(0){ init(checksumPlugin,autoBegin); }
+    inline void init(hpatch_TChecksum* checksumPlugin,bool autoBegin){
+        checkv(_checksumPlugin==0);
+        _checksumPlugin=checksumPlugin;
+        if (checksumPlugin){
+            _handle=checksumPlugin->open(checksumPlugin);
+            checkv(_handle!=0);
+            if (autoBegin) appendBegin();
+        }
+    }
+    inline ~CChecksum(){ if (_handle) _checksumPlugin->close(_checksumPlugin,_handle); }
+    inline void append(const unsigned char* data,const unsigned char* data_end){
+        if (_handle) _checksumPlugin->append(_handle,data,data_end); }
+    inline void append(const std::vector<TByte>& data){ if (!data.empty()) append(&data[0],&data[0]+data.size()); }
+    inline void append(const hpatch_TStreamInput* data){ append(data,0,data->streamSize); }
+    void append(const hpatch_TStreamInput* data,hpatch_StreamPos_t begin,hpatch_StreamPos_t end);
+    inline void appendBegin(){ if (_handle) _checksumPlugin->begin(_handle); }
+    inline void appendEnd(){
+        if (_handle){
+            checksum.resize(_checksumPlugin->checksumByteSize());
+            _checksumPlugin->end(_handle,&checksum[0],&checksum[0]+checksum.size());
+        }
+    }
+    hpatch_TChecksum*       _checksumPlugin;
+    hpatch_checksumHandle   _handle;
+    std::vector<TByte>      checksum;
+};
+    
+void pushTypes(std::vector<TByte>& out_data,const char* kTypeAndVersion,
+               const char* compressPluginType,hpatch_TChecksum* checksumPlugin);
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+
+struct TOffsetStreamOutput:public hpatch_TStreamOutput{
+    explicit TOffsetStreamOutput(const hpatch_TStreamOutput* base,hpatch_StreamPos_t offset);
+    const hpatch_TStreamOutput* _base;
+    hpatch_StreamPos_t          _offset;
+    hpatch_StreamPos_t          outSize;
+    static hpatch_BOOL _write(const hpatch_TStreamOutput* stream,const hpatch_StreamPos_t writeToPos,
+                              const unsigned char* data,const unsigned char* data_end);
+};
+    
+struct CFileResHandleLimit{
+    CFileResHandleLimit(size_t _limitMaxOpenCount,size_t resCount);
+    inline ~CFileResHandleLimit() { close(); }
+    void addBufRes(const hpatch_byte* bufRes,size_t bufResSize); //only support one
+    void addRes(const std::string& fileName,hpatch_StreamPos_t fileSize);
+    void open();
+    bool closeFileHandles();
+    void close();
+    
+    struct CFile:public hpatch_TFileStreamInput{
+        std::string          fileName;
+        CFileResHandleLimit* owner;
+    };
+    hpatch_TResHandleLimit          limit;
+    std::vector<CFile>              fileList;
+    std::vector<hpatch_IResHandle>  resList;
+    size_t                          limitMaxOpenCount;
+    size_t                          curInsert;
+    const hpatch_byte*              bufRes;
+    size_t                          bufResSize;
+    static hpatch_BOOL openRes(struct hpatch_IResHandle* res,hpatch_TStreamInput** out_stream);
+    static hpatch_BOOL closeRes(struct hpatch_IResHandle* res,const hpatch_TStreamInput* stream);
+    void _addRes(const std::string& fileName,hpatch_StreamPos_t fileSize);
+};
+
+struct CRefStream:public hpatch_TRefStream{
+    inline CRefStream(){ hpatch_TRefStream_init(this); }
+    void open(const hpatch_TStreamInput** refList,size_t refCount,size_t kAlignSize=1);
+    inline ~CRefStream(){ hpatch_TRefStream_close(this); }
+};
+
+size_t pushNameList(std::vector<TByte>& out_data,const char* rootPath,
+                    const std::string* nameList,size_t nameListSize);
+inline static size_t pushNameList(std::vector<TByte>& out_data,const std::string& rootPath,
+                                  const std::vector<std::string>& nameList){
+    return pushNameList(out_data,rootPath.c_str(),nameList.data(),nameList.size()); }
+
+void packList(std::vector<TByte>& out_data,const hpatch_StreamPos_t* list,size_t listSize);
+inline static void packList(std::vector<TByte>& out_data,const std::vector<hpatch_StreamPos_t>& list){
+    packList(out_data,list.data(),list.size()); }
+void packIncList(std::vector<TByte>& out_data,const size_t* list,size_t listSize);
+inline static void packIncList(std::vector<TByte>& out_data,const std::vector<size_t>& list){
+    packIncList(out_data,list.data(),list.size()); }
+
+#endif
+}
+
+#endif //hdiff_dir_diff_tools_h