react-native-update 10.34.3 → 10.34.5

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

@@ -33,8 +33,6 @@
 #include "../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.h"
 #include "../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/stream_serialize.h"
 #include "../../libHDiffPatch/HDiff/diff.h"
-#include "../../libHDiffPatch/HDiff/match_block.h"
-#include "../../libHDiffPatch/HPatch/patch.h"
 #include "../dir_patch/dir_patch.h"
 #include "../dir_patch/dir_patch_private.h"
 #include "dir_diff_tools.h"
@@ -50,11 +48,11 @@ static std::string  cmp_hash_type    =  "fadler64";
 #define cmp_hash_combine(ph,rightHash,rightLen) { (*(ph))=fast_adler64_by_combine(*(ph),rightHash,rightLen); }
 
 static cmp_hash_value_t getStreamHash(const hpatch_TStreamInput* stream,const std::string& errorTag){
-    TAutoMem  mem(hdiff_kFileIOBufBestSize);
+    TAutoMem  mem(hpatch_kFileIOBufBetterSize);
     cmp_hash_value_t result;
     cmp_hash_begin(&result);
     for (hpatch_StreamPos_t pos=0; pos<stream->streamSize;) {
-        size_t readLen=hdiff_kFileIOBufBestSize;
+        size_t readLen=hpatch_kFileIOBufBetterSize;
         if (pos+readLen>stream->streamSize)
             readLen=(size_t)(stream->streamSize-pos);
         check(stream->read(stream,pos,mem.data(),mem.data()+readLen),
@@ -79,9 +77,9 @@ static bool fileData_isSame(const std::string& file_x,const std::string& file_y,
     CFileStreamInput f_y(file_y);
     if (f_x.base.streamSize!=f_y.base.streamSize)
         return false;
-    TAutoMem  mem(hdiff_kFileIOBufBestSize*2);
+    TAutoMem  mem(hpatch_kFileIOBufBetterSize*2);
     for (hpatch_StreamPos_t pos=0; pos<f_x.base.streamSize;) {
-        size_t readLen=hdiff_kFileIOBufBestSize;
+        size_t readLen=hpatch_kFileIOBufBetterSize;
         if (pos+readLen>f_x.base.streamSize)
             readLen=(size_t)(f_x.base.streamSize-pos);
         check(f_x.base.read(&f_x.base,pos,mem.data(),mem.data()+readLen),
@@ -97,14 +95,6 @@ static bool fileData_isSame(const std::string& file_x,const std::string& file_y,
     return true;
 }
 
-static bool fileName_isSame(const std::string& file_x,const std::string& rootPath_x,
-                            const std::string& file_y,const std::string& rootPath_y){
-    size_t nameSize=file_x.size()-rootPath_x.size();
-    if (nameSize != (file_y.size()-rootPath_y.size()))
-        return false;
-    return 0==memcmp(file_x.c_str()+rootPath_x.size(),file_y.c_str()+rootPath_y.size(),nameSize);
-}
-
 static void packSamePairList(std::vector<TByte>& out_data,const std::vector<hpatch_TSameFilePair>& pairs){
     size_t backPairNew=~(size_t)0;
     size_t backPairOld=~(size_t)0;
@@ -270,27 +260,17 @@ struct CChecksumCombine:public CChecksum{
     cmp_hash_value_t        _combineHash;
 };
 
-static void _getExecuteList(std::vector<size_t>& outExecuteList,
-                            IDirDiffListener* listener,const std::vector<std::string>& pathList){
-    for (size_t i=0; i<pathList.size(); ++i) {
-        if ((!isDirName(pathList[i]))&&(listener->isExecuteFile(pathList[i])))
-            outExecuteList.push_back(i);
-    }
-}
-
 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 isLoadAll,size_t matchValue,const hdiff_TCompress* compressPlugin,
+              hpatch_TChecksum* checksumPlugin,size_t kMaxOpenFileNumber){
     assert(listener!=0);
     assert(kMaxOpenFileNumber>=kMaxOpenFileNumber_limit_min);
-    if ((checksumPlugin)&&(!hdiffSets.isDiffInMem)){
+    if ((checksumPlugin)&&(!isLoadAll)){
         check((outDiffStream->read_writed!=0),
               "for update checksum, outDiffStream->read_writed can't null error!");
     }
     kMaxOpenFileNumber-=1; // for outDiffStream
-    const size_t kMaxOpenFileNumber_old=kMaxOpenFileNumber*5/8;
-    const size_t kMaxOpenFileNumber_new=kMaxOpenFileNumber-kMaxOpenFileNumber_old;
     const std::vector<std::string>& oldList=oldManifest.pathList;
     const std::vector<std::string>& newList=newManifest.pathList;
     const bool oldIsDir=isDirName(oldManifest.rootPath);
@@ -303,9 +283,11 @@ void dir_diff(IDirDiffListener* listener,const TManifest& oldManifest,
     std::vector<size_t> newRefIList;
     std::vector<size_t> newExecuteList; //for linux etc
     
-    _getExecuteList(newExecuteList,listener,newList);
+    for (size_t newi=0; newi<newList.size(); ++newi) {
+        if ((!isDirName(newList[newi]))&&(listener->isExecuteFile(newList[newi])))
+            newExecuteList.push_back(newi);
+    }
     
-    _out_diff_info("  get old & new's file list infos ...\n");
     const bool isCachedHashs=(checksumPlugin!=0)&&(checksumPlugin->checksumType()==cmp_hash_type);
     if (isCachedHashs) checkv(sizeof(cmp_hash_value_t)==checksumPlugin->checksumByteSize());
     std::vector<cmp_hash_value_t> oldHashList;
@@ -313,43 +295,25 @@ void dir_diff(IDirDiffListener* listener,const TManifest& oldManifest,
     getRefList(oldManifest.rootPath,newManifest.rootPath,oldList,newList,
                oldSizeList,newSizeList,dataSamePairList,oldRefIList,newRefIList,
                isCachedHashs,oldHashList,newHashList);
-    if (hdiffSets.isCheckNotEqual){
-        bool isEq=(oldIsDir==newIsDir)
-                &&(oldList.size()==newList.size()) //same file count
-                &&(oldSizeList==newSizeList)
-                &&oldRefIList.empty()&&newRefIList.empty(); //same file datas;
-         //same names
-        for (size_t i=0;isEq&&(i<oldList.size());++i){
-            isEq=fileName_isSame(oldList[i],oldManifest.rootPath,newList[i],newManifest.rootPath);
-        }
-        //same execute tags
-        for (size_t i=0;isEq&&(i<newExecuteList.size());++i){
-            const std::string& oldfile=oldList[newExecuteList[i]];
-            isEq=(!isDirName(oldfile))&&(listener->isExecuteFile(oldfile));
-        }
-        check(!isEq,"old & new's all datas can't be equal");
-    }
     std::vector<hpatch_StreamPos_t> newRefSizeList;
-    CFileResHandleLimit resLimit_old(kMaxOpenFileNumber_old,oldRefIList.size());
-    CFileResHandleLimit resLimit_new(kMaxOpenFileNumber_new,newRefIList.size());
+    CFileResHandleLimit resLimit(kMaxOpenFileNumber,oldRefIList.size()+newRefIList.size());
     {
         for (size_t i=0; i<oldRefIList.size(); ++i) {
             size_t fi=oldRefIList[i];
-            resLimit_old.addRes(oldList[fi],oldSizeList[fi]);
+            resLimit.addRes(oldList[fi],oldSizeList[fi]);
         }
         newRefSizeList.resize(newRefIList.size());
         for (size_t i=0; i<newRefIList.size(); ++i) {
             size_t fi=newRefIList[i];
             newRefSizeList[i]=newSizeList[fi];
-            resLimit_new.addRes(newList[fi],newSizeList[fi]);
+            resLimit.addRes(newList[fi],newSizeList[fi]);
         }
     }
-    resLimit_old.open();
-    resLimit_new.open();
+    resLimit.open();
     CRefStream oldRefStream;
     CRefStream newRefStream;
-    oldRefStream.open(resLimit_old.limit.streamList,oldRefIList.size());
-    newRefStream.open(resLimit_new.limit.streamList,newRefIList.size());
+    oldRefStream.open(resLimit.limit.streamList,oldRefIList.size());
+    newRefStream.open(resLimit.limit.streamList+oldRefIList.size(),newRefIList.size());
     
     //checksum
     const size_t checksumByteSize=(checksumPlugin==0)?0:checksumPlugin->checksumByteSize();
@@ -484,27 +448,27 @@ void dir_diff(IDirDiffListener* listener,const TManifest& oldManifest,
     //diff data
     listener->runHDiffBegin();
     hpatch_StreamPos_t diffDataSize=0;
-    {
-        const hdiff_TMTSets_s mtsets={hdiffSets.threadNum,hdiffSets.threadNumSearch_s,false,false};
+    if (isLoadAll){
+        hpatch_StreamPos_t memSize=newRefStream.stream->streamSize+oldRefStream.stream->streamSize;
+        check(memSize==(size_t)memSize,"alloc size overflow error!");
+        TAutoMem  mem((size_t)memSize);
+        TByte* newData=mem.data();
+        TByte* oldData=mem.data()+newRefStream.stream->streamSize;
+        check(newRefStream.stream->read(newRefStream.stream,0,newData,
+                                        newData+newRefStream.stream->streamSize),"read new file error!");
+        check(oldRefStream.stream->read(oldRefStream.stream,0,oldData,
+                                        oldData+oldRefStream.stream->streamSize),"read old file error!");
+        resLimit.close(); //close files
+        std::vector<TByte> out_diff;
+        create_compressed_diff(newData,newData+newRefStream.stream->streamSize,
+                               oldData,oldData+oldRefStream.stream->streamSize,
+                               out_diff,compressPlugin,(int)matchValue);
+        diffDataSize=out_diff.size();
+        _pushv(out_diff);
+    }else{
         TOffsetStreamOutput ofStream(outDiffStream,writeToPos);
-        if (hdiffSets.isSingleCompressedDiff){
-            if (hdiffSets.isDiffInMem)
-                create_single_compressed_diff_block(newRefStream.stream,oldRefStream.stream,&ofStream,compressPlugin,
-                                                    (int)hdiffSets.matchScore,hdiffSets.patchStepMemSize,hdiffSets.isUseBigCacheMatch,
-                                                    hdiffSets.matchBlockSize,hdiffSets.threadNum,hdiffSets.threadNumSearch_s);
-            else
-                create_single_compressed_diff_stream(newRefStream.stream,oldRefStream.stream,&ofStream,
-                                                     compressPlugin,hdiffSets.matchBlockSize,
-                                                     hdiffSets.patchStepMemSize,&mtsets);
-        }else{
-            if (hdiffSets.isDiffInMem)
-                create_compressed_diff_block(newRefStream.stream,oldRefStream.stream,&ofStream,compressPlugin,
-                                             (int)hdiffSets.matchScore,hdiffSets.isUseBigCacheMatch,
-                                             hdiffSets.matchBlockSize,hdiffSets.threadNum,hdiffSets.threadNumSearch_s);
-            else
-                create_compressed_diff_stream(newRefStream.stream,oldRefStream.stream,&ofStream,
-                                              compressPlugin,hdiffSets.matchBlockSize,&mtsets);
-        }
+        create_compressed_diff_stream(newRefStream.stream,oldRefStream.stream,&ofStream,
+                                      compressPlugin,matchValue);
         diffDataSize=ofStream.outSize;
         if (checksumByteSize>0){
             assert(outDiffStream->read_writed!=0);
@@ -523,14 +487,14 @@ void dir_diff(IDirDiffListener* listener,const TManifest& oldManifest,
     #undef _pushv
 }
 
-#define _test(value) { if (!(value)) { LOG_ERR("DirPatch check "#value" error!\n");  return hpatch_FALSE; } }
+#define _test(value) { if (!(value)) { fprintf(stderr,"DirPatch check "#value" error!\n");  return hpatch_FALSE; } }
 
 struct CDirPatchListener:public IDirPatchListener{
     explicit CDirPatchListener(const std::string& newRootDir,
                                const std::vector<std::string>& oldList,
                                const std::vector<std::string>& newList)
     :_oldSet(oldList.begin(),oldList.end()),_newSet(newList.begin(),newList.end()),
-    _buf(hdiff_kFileIOBufBestSize){
+    _buf(hpatch_kFileIOBufBetterSize){
         _dirSet.insert(getParentDir(newRootDir));
         this->listenerImport=this;
         this->makeNewDir=_makeNewDir;
@@ -588,7 +552,7 @@ struct CDirPatchListener:public IDirPatchListener{
                 newData=&newFile.base;
                 streamSize=newData->streamSize;
             }else{
-                streamSize=hpatch_kNullStreamPos;
+                streamSize=~(hpatch_StreamPos_t)0;
             }
             streamImport=this;
             read_writed=0;
@@ -655,7 +619,7 @@ struct CDirPatcher:public TDirPatcher{
 
 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){
+                   hpatch_TChecksum* checksumPlugin,size_t kMaxOpenFileNumber){
     bool     result=true;
     assert(kMaxOpenFileNumber>=kMaxOpenFileNumber_limit_min);
     const std::vector<std::string>& oldList=oldManifest.pathList;
@@ -665,7 +629,9 @@ bool check_dirdiff(IDirDiffListener* listener,const TManifest& oldManifest,const
     CDirPatcher          dirPatcher;
     const TDirDiffInfo*  dirDiffInfo=0;
     TDirPatchChecksumSet    checksumSet={checksumPlugin,hpatch_TRUE,hpatch_TRUE,hpatch_TRUE,hpatch_TRUE};
-
+    TAutoMem             p_temp_mem(hpatch_kFileIOBufBetterSize*4);
+    TByte*               temp_cache=p_temp_mem.data();
+    size_t               temp_cache_size=p_temp_mem.size();
     const hpatch_TStreamInput*  oldStream=0;
     const hpatch_TStreamOutput* newStream=0;
     {//dir diff info
@@ -684,21 +650,13 @@ bool check_dirdiff(IDirDiffListener* listener,const TManifest& oldManifest,const
             _test(kPathType_file==oldType);
         }
     }
-
-    //mem
-    size_t      temp_cache_size=hdiff_kFileIOBufBestSize*(1+16);
-    if (dirDiffInfo->isSingleCompressedDiff)
-        temp_cache_size+=(size_t)dirDiffInfo->sdiffInfo.stepMemSize;
-    TAutoMem    p_temp_mem(temp_cache_size);
-    TByte*      temp_cache=p_temp_mem.data();
-
     if (checksumPlugin)
-        _test(TDirPatcher_checksum(&dirPatcher,&checksumSet,temp_cache,temp_cache+temp_cache_size));
+        _test(TDirPatcher_checksum(&dirPatcher,&checksumSet));
     _test(TDirPatcher_loadDirData(&dirPatcher,decompressPlugin,
                                   oldManifest.rootPath.c_str(),newManifest.rootPath.c_str()));
     _test(TDirPatcher_openOldRefAsStream(&dirPatcher,kMaxOpenFileNumber,&oldStream));
     _test(TDirPatcher_openNewDirAsStream(&dirPatcher,&patchListener,&newStream));
-    _test(TDirPatcher_patch(&dirPatcher,newStream,oldStream,temp_cache,temp_cache+temp_cache_size,threadNum));
+    _test(TDirPatcher_patch(&dirPatcher,newStream,oldStream,temp_cache,temp_cache+temp_cache_size));
     _test(TDirPatcher_closeNewDirStream(&dirPatcher));
     _test(TDirPatcher_closeOldRefStream(&dirPatcher));
     _test(patchListener.isNewOk());
@@ -707,10 +665,10 @@ bool check_dirdiff(IDirDiffListener* listener,const TManifest& oldManifest,const
 #undef _test
 
 
-#define _check(value) { if (!(value)) { LOG_ERR("dirOldDataChecksum check "#value" error!\n"); \
+#define _check(value) { if (!(value)) { fprintf(stderr,"dirOldDataChecksum check "#value" error!\n"); \
                             result= hpatch_FALSE; goto clear; } }
 hpatch_BOOL check_dirOldDataChecksum(const char* oldPath,hpatch_TStreamInput* diffData,
-                                     hpatch_TDecompress* decompressPlugin,hpatch_TChecksum* checksumPlugin){
+                                     hpatch_TDecompress *decompressPlugin,hpatch_TChecksum *checksumPlugin){
     hpatch_BOOL  result=hpatch_TRUE;
     hpatch_BOOL         isAppendContinue=hpatch_FALSE;
     hpatch_StreamPos_t  readPos=0;
@@ -736,7 +694,7 @@ hpatch_BOOL check_dirOldDataChecksum(const char* oldPath,hpatch_TStreamInput* di
                      TDirOldDataChecksum_getChecksumType(&oldCheck)));
     savedCompressType=TDirOldDataChecksum_getCompressType(&oldCheck);
     _check(((decompressPlugin==0)&&(strlen(savedCompressType)==0))||
-           (decompressPlugin&&decompressPlugin->is_can_open(savedCompressType)));
+           decompressPlugin->is_can_open(savedCompressType));
     _check(TDirOldDataChecksum_checksum(&oldCheck,decompressPlugin,checksumPlugin,oldPath));
 clear:
     if (!TDirOldDataChecksum_close(&oldCheck)) result=hpatch_FALSE;
@@ -820,14 +778,7 @@ void resave_dirdiff(const hpatch_TStreamInput* in_diff,hpatch_TDecompress* decom
     {//resave hdiffData
         TOffsetStreamOutput ofStream(out_diff,writeToPos);
         TStreamClip clip(in_diff,head.hdiffDataOffset,head.hdiffDataOffset+head.hdiffDataSize);
-        
-        hpatch_singleCompressedDiffInfo singleDiffInfo;
-        hpatch_BOOL isSingleStreamDiff=getSingleCompressedDiffInfo(&singleDiffInfo,&clip,0);
-        if (isSingleStreamDiff){
-            resave_single_compressed_diff(&clip,decompressPlugin,&ofStream,compressPlugin,&singleDiffInfo);
-        }else{
-            resave_compressed_diff(&clip,decompressPlugin,&ofStream,compressPlugin);
-        }
+        resave_compressed_diff(&clip,decompressPlugin,&ofStream,compressPlugin);
         writeToPos+=ofStream.outSize;
     }
     if (checksumByteSize>0){// update dirdiff checksum

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

@@ -29,20 +29,6 @@
 #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"
 
@@ -61,15 +47,15 @@ struct IDirDiffListener{
 
 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 isLoadAll,size_t matchValue,const hdiff_TCompress* compressPlugin,
+              hpatch_TChecksum* checksumPlugin,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);
+                   hpatch_TChecksum* checksumPlugin,size_t kMaxOpenFileNumber);
 
 //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);
+                                     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,

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

@@ -28,131 +28,20 @@
  */
 #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_TPathType   type;
         hpatch_StreamPos_t fileSize;
-        checkv(hpatch_getFileSize(fileName.c_str(),&fileSize));
+        checkv(hpatch_getPathStat(fileName.c_str(),&type,&fileSize));
+        checkv(type==kPathType_file);
         return fileSize;
     }
     
     
     void CChecksum::append(const hpatch_TStreamInput* data,hpatch_StreamPos_t begin,hpatch_StreamPos_t end){
         if (!_handle) return;
-        TAutoMem buf(hdiff_kFileIOBufBestSize);
+        TAutoMem buf(hpatch_kFileIOBufBetterSize);
         while (begin<end){
             size_t len=buf.size();
             if (len>(end-begin))
@@ -193,8 +82,6 @@ namespace hdiff_private{
     
 #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);
@@ -264,7 +151,7 @@ namespace hdiff_private{
 
     
     CFileResHandleLimit::CFileResHandleLimit(size_t _limitMaxOpenCount,size_t resCount)
-    :limitMaxOpenCount(_limitMaxOpenCount),curInsert(0),bufRes(0),bufResSize(0){
+    :limitMaxOpenCount(_limitMaxOpenCount),curInsert(0){
         hpatch_TResHandleLimit_init(&limit);
         resList.resize(resCount);
         memset(resList.data(),0,sizeof(hpatch_IResHandle)*resCount);
@@ -273,21 +160,9 @@ namespace hdiff_private{
             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;
@@ -310,30 +185,16 @@ namespace hdiff_private{
     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!");
-        }
+        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!");
-        }
+        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

@@ -30,7 +30,6 @@
 #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"
@@ -68,8 +67,7 @@ inline static void writeStream(const hpatch_TStreamOutput* out_stream,hpatch_Str
 }
 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());
+    writeStream(out_stream,outPos,buf.data(),buf.data()+buf.size());
 }
 
 struct CFileStreamInput:public hpatch_TFileStreamInput{
@@ -96,29 +94,24 @@ struct CFileStreamOutput:public hpatch_TFileStreamOutput{
 };
 
 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;
+    :_checksumPlugin(checksumPlugin),_handle(0){
         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 std::vector<TByte>& data){ append(data.data(),data.data()+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());
+            _checksumPlugin->end(_handle,checksum.data(),checksum.data()+checksum.size());
         }
     }
     hpatch_TChecksum*       _checksumPlugin;
@@ -143,26 +136,21 @@ struct TOffsetStreamOutput:public hpatch_TStreamOutput{
 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;
+        std::string  fileName;
     };
     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{