react-native-update 10.34.1 → 10.34.3

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

@@ -0,0 +1,246 @@
+// dir_patch.h
+// hdiffz dir patch
+//
+/*
+ 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 DirPatch_dir_patch_h
+#define DirPatch_dir_patch_h
+#include "dir_patch_types.h"
+#include "../../libHDiffPatch/HPatch/checksum_plugin.h"
+    typedef struct TDirPatchChecksumSet{
+        hpatch_TChecksum*   checksumPlugin;
+        hpatch_BOOL         isCheck_oldRefData;
+        hpatch_BOOL         isCheck_newRefData;  
+        hpatch_BOOL         isCheck_copyFileData;
+        hpatch_BOOL         isCheck_dirDiffData;
+    } TDirPatchChecksumSet;
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#include "ref_stream.h"
+#include "new_stream.h"
+#include "res_handle_limit.h"
+#include "new_dir_output.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+typedef struct TDirDiffInfo{
+    hpatch_BOOL                 isDirDiff;
+    hpatch_BOOL                 newPathIsDir;
+    hpatch_BOOL                 oldPathIsDir;
+    hpatch_BOOL                 dirDataIsCompressed;
+    //compressType saved in hdiffInfo
+    hpatch_compressedDiffInfo   hdiffInfo;
+#if (_IS_NEED_SINGLE_STREAM_DIFF)
+    hpatch_BOOL         isSingleCompressedDiff;
+    hpatch_singleCompressedDiffInfo sdiffInfo;
+#endif
+    hpatch_StreamPos_t          externDataOffset;
+    hpatch_StreamPos_t          externDataSize;
+    hpatch_StreamPos_t          checksumOffset;
+    size_t                      checksumByteSize;
+    char                        checksumType[hpatch_kMaxPluginTypeLength+1]; //ascii cstring
+} TDirDiffInfo;
+
+
+hpatch_BOOL getDirDiffInfo(TDirDiffInfo* out_info,const hpatch_TStreamInput* diffFile);
+hpatch_BOOL getDirDiffInfoByFile(TDirDiffInfo* out_info,const char* diffFileName,
+                                 hpatch_StreamPos_t diffDataOffert,hpatch_StreamPos_t diffDataSize);
+static hpatch_inline
+hpatch_BOOL getIsDirDiffFile(const char* diffFileName){
+     TDirDiffInfo dirDiffInfo;
+    if (!getDirDiffInfoByFile(&dirDiffInfo,diffFileName,0,0)) return hpatch_FALSE;
+    return dirDiffInfo.isDirDiff;
+}
+
+    typedef struct _TDirDiffHead {
+        size_t              oldPathCount;
+        size_t              oldPathSumSize;
+        size_t              newPathCount;
+        size_t              newPathSumSize;
+        size_t              oldRefFileCount;
+        size_t              newRefFileCount;
+        size_t              sameFilePairCount;
+        size_t              newExecuteCount;
+        size_t              privateReservedDataSize;
+        hpatch_StreamPos_t  sameFileSize;
+        hpatch_StreamPos_t  typesEndPos;
+        hpatch_StreamPos_t  privateExternDataOffset; //headDataEndPos
+        hpatch_StreamPos_t  privateExternDataSize;
+        hpatch_StreamPos_t  compressSizeBeginPos;
+        hpatch_StreamPos_t  headDataOffset;
+        hpatch_StreamPos_t  headDataSize;
+        hpatch_StreamPos_t  headDataCompressedSize;
+        hpatch_StreamPos_t  hdiffDataOffset;
+        hpatch_StreamPos_t  hdiffDataSize;
+    } _TDirDiffHead;
+    
+    struct hpatch_TFileStreamInput;
+    struct hpatch_TFileStreamOutput;
+    
+typedef struct TDirPatcher{
+    TDirDiffInfo                dirDiffInfo;
+    _TDirDiffHead               dirDiffHead;
+    const char* const *         oldUtf8PathList;
+    const size_t*               oldRefList;
+    hpatch_BOOL                 _isDiffDataChecksumError;
+    hpatch_BOOL                 _isOldRefDataChecksumError;
+//private:
+    TNewDirOutput               _newDir;
+    
+    hpatch_TRefStream           _oldRefStream;
+    hpatch_TResHandleLimit      _resLimit;
+    hpatch_IResHandle*          _resList;
+    struct hpatch_TFileStreamInput*    _oldFileList;
+    const char*                 _oldRootDir;
+    size_t                      _oldRootDir_len;
+    void*                       _pOldRefMem;
+    
+    hpatch_ICopyDataListener    _sameFileCopyListener;
+    
+    TDirPatchChecksumSet        _checksumSet;
+    unsigned char*              _pChecksumMem;
+    
+    hpatch_TDecompress*         _decompressPlugin;
+    const hpatch_TStreamInput*  _dirDiffData;
+    void*                       _pDiffDataMem;
+    size_t*                     _pOldSameRefCount;
+    hpatch_FileError_t          fileError;
+} TDirPatcher;
+
+hpatch_inline
+static void TDirPatcher_init(TDirPatcher* self)  { memset(self,0,sizeof(*self)); }
+hpatch_BOOL TDirPatcher_open(TDirPatcher* self,const hpatch_TStreamInput* dirDiffData,
+                             const TDirDiffInfo** out_dirDiffInfo);
+//if checksumSet->isCheck_dirDiffData then result&=checksum(dirDiffData);
+hpatch_BOOL TDirPatcher_checksum(TDirPatcher* self,const TDirPatchChecksumSet* checksumSet,
+			                	 hpatch_byte* tempBuf,hpatch_byte* tempBufEnd);
+hpatch_BOOL TDirPatcher_loadDirData(TDirPatcher* self,hpatch_TDecompress* decompressPlugin,
+                                    const char* oldPath_utf8,const char* newPath_utf8);
+
+hpatch_BOOL TDirPatcher_openOldRefAsStream(TDirPatcher* self,size_t kMaxOpenFileNumber,
+                                           const hpatch_TStreamInput** out_oldRefStream);
+hpatch_BOOL TDirPatcher_openNewDirAsStream(TDirPatcher* self,IDirPatchListener* listener,
+                                           const hpatch_TStreamOutput** out_newDirStream);
+hpatch_BOOL TDirPatcher_patch(TDirPatcher* self,const hpatch_TStreamOutput* out_newData,
+                              const hpatch_TStreamInput* oldData,
+                              unsigned char* temp_cache,unsigned char* temp_cache_end,size_t threadNum);
+    
+static hpatch_inline
+hpatch_BOOL TDirPatcher_isCopyDataChecksumError(const TDirPatcher* self)
+                            { return self->_newDir._isCopyDataChecksumError; }
+static hpatch_inline
+hpatch_BOOL TDirPatcher_isNewRefDataChecksumError(const TDirPatcher* self)
+                            { return self->_newDir._isNewRefDataChecksumError; }
+static hpatch_inline
+hpatch_BOOL TDirPatcher_isDiffDataChecksumError(const TDirPatcher* self)
+                            { return self->_isDiffDataChecksumError; }
+static hpatch_inline
+hpatch_BOOL TDirPatcher_isOldRefDataChecksumError(const TDirPatcher* self)
+                            { return self->_isOldRefDataChecksumError; }
+
+static hpatch_inline
+size_t      TDirPatcher_getNewExecuteFileCount(const TDirPatcher* self) {
+                                               return self->dirDiffHead.newExecuteCount;  }
+static hpatch_inline const char* TDirPatcher_getNewExecuteFileByIndex(const TDirPatcher* self,size_t newExecuteIndex,
+                                                                      char* out_pathBuf,char* out_pathBufEnd)
+    { return TNewDirOutput_getNewExecuteFileByIndex(&self->_newDir,newExecuteIndex,out_pathBuf,out_pathBufEnd); }
+
+hpatch_BOOL TDirPatcher_closeOldRefStream(TDirPatcher* self);//for TDirPatcher_openOldRefAsStream
+hpatch_BOOL TDirPatcher_closeNewDirStream(TDirPatcher* self);//for TDirPatcher_openNewDirAsStream
+hpatch_BOOL TDirPatcher_close(TDirPatcher* self);
+
+//can be called after TDirPatcher_loadDirData
+const char* TDirPatcher_getOldPathByIndex(const TDirPatcher* self,size_t oldPathIndex,
+                                          char* out_pathBuf,char* out_pathBufEnd);
+const char* TDirPatcher_getOldRefPathByRefIndex(const TDirPatcher* self,size_t oldRefIndex,
+                                                char* out_pathBuf,char* out_pathBufEnd);
+const char* TDirPatcher_getOldPathByNewPath(const TDirPatcher* self,const char* newPath,
+                                            char* out_pathBuf,char* out_pathBufEnd);
+static hpatch_inline const char* TDirPatcher_getNewPathRoot(const TDirPatcher* self)
+    { return TNewDirOutput_getNewPathRoot(&self->_newDir); }
+static hpatch_inline const char* TDirPatcher_getNewPathByIndex(const TDirPatcher* self,size_t newPathIndex,
+                                                               char* out_pathBuf,char* out_pathBufEnd)
+    { return TNewDirOutput_getNewPathByIndex(&self->_newDir,newPathIndex,out_pathBuf,out_pathBufEnd); }
+static hpatch_inline const char* TDirPatcher_getOldPathBySameIndex(const TDirPatcher* self,size_t sameIndex,
+                                                                   char* out_pathBuf,char* out_pathBufEnd)
+    { return TNewDirOutput_getOldPathBySameIndex(&self->_newDir,sameIndex,out_pathBuf,out_pathBufEnd); }
+static hpatch_inline const char* TDirPatcher_getNewPathBySameIndex(const TDirPatcher* self,size_t sameIndex,
+                                                                   char* out_pathBuf,char* out_pathBufEnd)
+    { return TNewDirOutput_getNewPathBySameIndex(&self->_newDir,sameIndex,out_pathBuf,out_pathBufEnd); }
+static hpatch_inline void TDirPatcher_getNewExecuteList(TDirPatcher* self,IDirPathList* out_executeList)
+    { TNewDirOutput_getExecuteList(&self->_newDir,out_executeList); }
+static hpatch_inline void TDirPatcher_getNewDirPathList(TDirPatcher* self,IDirPathList* out_newPathList)
+    { TNewDirOutput_getNewDirPathList(&self->_newDir,out_newPathList); }
+static hpatch_inline void TDirPatcher_getOldDirPathList(TDirPatcher* self,IDirPathList* out_oldPathList){
+    out_oldPathList->import=self;
+    out_oldPathList->pathCount=self->dirDiffHead.oldPathCount;
+    out_oldPathList->getPathNameByIndex=(IDirPathList_getPathNameByIndex)TDirPatcher_getOldPathByIndex;
+}
+const char* TDirPatcher_getOldExecuteFileByNewExecuteIndex(const TDirPatcher* self,size_t newExecuteIndex,
+                                                           char* out_pathBuf,char* out_pathBufEnd);
+
+hpatch_BOOL TDirPatcher_initOldSameRefCount(TDirPatcher* self);
+void        TDirPatcher_finishOldSameRefCount(TDirPatcher* self);
+const char* TDirPatcher_getOldPathBySameIndex(const TDirPatcher* self,size_t sameIndex,
+                                              char* out_pathBuf,char* out_pathBufEnd);
+const char* TDirPatcher_getNewPathBySameIndex(const TDirPatcher* self,size_t sameIndex,
+                                              char* out_pathBuf,char* out_pathBufEnd);
+size_t      TDirPatcher_oldSameRefCount(TDirPatcher* self,size_t sameIndex);
+void        TDirPatcher_decOldSameRefCount(TDirPatcher* self,size_t sameIndex);
+    
+
+
+//can checksum oldData(oldRefFiles+oldCopyFiles) by head of dirDiffData,not need download all data;
+typedef struct TDirOldDataChecksum{
+//private:
+    TDirPatcher         _dirPatcher;
+    unsigned char*      _partDiffData;
+    unsigned char*      _partDiffData_cur;
+    unsigned char*      _partDiffData_end;
+    hpatch_TStreamInput _diffStream;
+    hpatch_BOOL         _isOpened;
+    hpatch_BOOL         _isAppendStoped;
+} TDirOldDataChecksum;
+hpatch_inline
+static void TDirOldDataChecksum_init(TDirOldDataChecksum* self)  { memset(self,0,sizeof(*self)); }
+//if dirDiffData_part==dirDiffData_part_end means dirDiffData finished
+hpatch_BOOL TDirOldDataChecksum_append(TDirOldDataChecksum* self,unsigned char* dirDiffData_part,
+                                       unsigned char* dirDiffData_part_end,hpatch_BOOL* out_isAppendContinue);
+const char* TDirOldDataChecksum_getChecksumType(const TDirOldDataChecksum* self);
+const char* TDirOldDataChecksum_getCompressType(const TDirOldDataChecksum* self);
+
+//open read the needed old files,check file sum size,and checksum file data
+hpatch_BOOL TDirOldDataChecksum_checksum(TDirOldDataChecksum* self,hpatch_TDecompress* decompressPlugin,
+                                         hpatch_TChecksum* checksumPlugin,const char* oldPath_utf8);
+
+hpatch_BOOL TDirOldDataChecksum_close(TDirOldDataChecksum* self);
+    
+#ifdef __cplusplus
+}
+#endif
+#endif
+#endif //DirPatch_dir_patch_h

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/dir_patch_private.h

@@ -0,0 +1,47 @@
+// dir_patch_private.h
+// dir patch
+//
+/*
+ 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 DirPatch_dir_patch_private_h
+#define DirPatch_dir_patch_private_h
+#include "dir_patch_types.h"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct TDirDiffInfo;
+struct _TDirDiffHead;
+
+hpatch_BOOL read_dirdiff_head(struct TDirDiffInfo* out_info,struct _TDirDiffHead* out_head,
+                              const hpatch_TStreamInput* dirDiffFile);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+#endif //DirPatch_dir_patch_private_h

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/dir_patch_tools.c

@@ -0,0 +1,112 @@
+// dir_patch_tools.c
+// hdiffz dir patch
+//
+/*
+ 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_patch_tools.h"
+#include "../../file_for_patch.h"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#include <stdio.h>
+#include <string.h>
+
+#define TUInt hpatch_StreamPos_t
+
+#define  checki(value,errorInfo) { if (!(value)){ LOG_ERR("dir_patch " errorInfo " error!\n");  \
+                                       result=hpatch_FALSE; goto clear; } }
+
+void formatDirTagForLoad(char* utf8_path,char* utf8_pathEnd){
+    if (kPatch_dirSeparator==kPatch_dirSeparator_saved) return;
+    for (;utf8_path<utf8_pathEnd;++utf8_path){
+        if ((*utf8_path)!=kPatch_dirSeparator_saved)
+            continue;
+        else
+            *utf8_path=kPatch_dirSeparator;
+    }
+}
+
+hpatch_BOOL clipCStrsTo(const char* cstrs,const char* cstrsEnd,
+                        const char** out_cstrList,size_t cstrCount){
+    if (cstrs<cstrsEnd){
+        if (cstrsEnd[-1]!='\0') return hpatch_FALSE;
+        while ((cstrs<cstrsEnd)&(cstrCount>0)) {
+            *out_cstrList=cstrs;  ++out_cstrList; --cstrCount;
+            cstrs+=strlen(cstrs)+1; //safe
+        }
+    }
+    return (cstrs==cstrsEnd)&(cstrCount==0);
+}
+
+hpatch_BOOL readListTo(TStreamCacheClip* sclip,hpatch_StreamPos_t* out_list,size_t count){
+    hpatch_BOOL result=hpatch_TRUE;
+    size_t i;
+    for (i=0; i<count; ++i) {
+        checki(_TStreamCacheClip_unpackUIntWithTag(sclip,&out_list[i],0),
+               "readListTo() saved data");
+    }
+clear:
+    return result;
+}
+
+hpatch_BOOL readIncListTo(TStreamCacheClip* sclip,size_t* out_list,
+                          size_t count,size_t check_endValue){
+    //endValue: maxValue+1
+    hpatch_BOOL result=hpatch_TRUE;
+    TUInt backValue=~(TUInt)0;
+    size_t i;
+    for (i=0; i<count; ++i) {
+        TUInt incValue;
+        checki(_TStreamCacheClip_unpackUIntWithTag(sclip,&incValue,0),"readIncListTo() saved data");
+        backValue+=1+incValue;
+        checki(backValue<check_endValue,"readIncListTo() saved data value");
+        out_list[i]=(size_t)backValue;
+    }
+clear:
+    return result;
+}
+
+char* _setPath(char* out_path,char* out_pathBufEnd,const char* fileName,size_t fileNameLen){
+    char* result=0; //false
+    checki(fileNameLen+1<=(size_t)(out_pathBufEnd-out_path),"_setPath() out_path buf size");
+    memcpy(out_path,fileName,fileNameLen+1);//with '\0'
+    result=out_path+fileNameLen;
+clear:
+    return result;
+}
+
+char* _setDirPath(char* out_path,char* out_pathBufEnd,const char* dirName,size_t dirNameLen){
+    char* result=0; //false
+    hpatch_BOOL isNeedDirSeparator=(dirNameLen>0)&&(dirName[dirNameLen-1]!=kPatch_dirSeparator);
+    checki((dirNameLen+(isNeedDirSeparator?1:0)+1)<=(size_t)(out_pathBufEnd-out_path),
+           "_setDirPath() out_path buf size");
+    memcpy(out_path,dirName,dirNameLen);
+    result=out_path+dirNameLen;
+    if (isNeedDirSeparator) { *result=kPatch_dirSeparator; ++result; }
+    *result='\0'; //C string end
+clear:
+    return result;
+}
+
+#endif

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/dir_patch_tools.h

@@ -0,0 +1,69 @@
+// dir_patch_tools.h
+// hdiffz dir patch
+//
+/*
+ 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 DirPatch_dir_patch_tools_h
+#define DirPatch_dir_patch_tools_h
+#include "dir_patch_types.h"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#include "../../libHDiffPatch/HPatch/patch_private.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+    void formatDirTagForLoad(char* utf8_path,char* utf8_pathEnd);
+    hpatch_BOOL clipCStrsTo(const char* cstrs,const char* cstrsEnd,
+                            const char** out_cstrList,size_t cstrCount);
+    hpatch_BOOL readListTo(TStreamCacheClip* sclip,hpatch_StreamPos_t* out_list,size_t count);
+    hpatch_BOOL readIncListTo(TStreamCacheClip* sclip,size_t* out_list,
+                              size_t count,size_t check_endValue);
+    
+    char* _setPath(char* out_path,char* out_pathBufEnd,const char* fileName,size_t fileNameLen);
+    //return path end pos
+    static hpatch_force_inline
+    char* setPath(char* out_path,char* out_pathBufEnd,const char* fileName){ 
+                    return _setPath(out_path,out_pathBufEnd,fileName,strlen(fileName)); }
+    static hpatch_force_inline
+    char* setPathWithRoot(char* out_path,char* out_pathBufEnd,const char* root_path,size_t root_pathLen,const char* fileName){
+                                char* resultEnd=_setPath(out_path,out_pathBufEnd,root_path,root_pathLen);
+                                if (resultEnd) resultEnd=setPath(resultEnd,out_pathBufEnd,fileName);
+                                return resultEnd;   }
+
+    char* _setDirPath(char* out_path,char* out_pathBufEnd,const char* dirName,size_t dirNameLen);
+    static hpatch_force_inline
+    char* setDirPath(char* out_path,char* out_pathBufEnd,const char* dirName){
+                        return _setDirPath(out_path,out_pathBufEnd,dirName,strlen(dirName)); }
+    static hpatch_force_inline
+    char* setDirPathWithRoot(char* out_path,char* out_pathBufEnd,char* root_path,size_t root_pathLen,const char* dirName){
+                                    char* resultEnd=_setPath(out_path,out_pathBufEnd,root_path,root_pathLen);
+                                    if (resultEnd) resultEnd=setDirPath(resultEnd,out_pathBufEnd,dirName);
+                                    return resultEnd;  }
+    
+#ifdef __cplusplus
+}
+#endif
+#endif
+#endif //DirPatch_dir_patch_tools_h

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/dir_patch_types.h

@@ -0,0 +1,65 @@
+// dir_patch_types.h
+// dir patch
+//
+/*
+ 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 DirPatch_dir_patch_types_h
+#define DirPatch_dir_patch_types_h
+#include "../../libHDiffPatch/HPatch/patch_types.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _IS_NEED_DIR_DIFF_PATCH
+#   define _IS_NEED_DIR_DIFF_PATCH  1
+#endif
+#ifndef _IS_NEED_SINGLE_STREAM_DIFF
+#   define _IS_NEED_SINGLE_STREAM_DIFF 1
+#endif
+
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#   define kMaxOpenFileNumber_limit_min          5
+#   define kMaxOpenFileNumber_default_min       16 //must >= limit_min
+#   define kMaxOpenFileNumber_default_diff      64
+#   define kMaxOpenFileNumber_default_patch     24
+#endif
+
+#ifdef _WIN32
+static const char kPatch_dirSeparator = '\\';
+#else
+static const char kPatch_dirSeparator = '/';
+#endif
+static const char kPatch_dirSeparator_saved = '/';
+
+static hpatch_inline  //align upper
+hpatch_StreamPos_t toAlignRangeSize(hpatch_StreamPos_t rangeSize,size_t kAlignSize)
+        { return (rangeSize+kAlignSize-1)/kAlignSize*kAlignSize; }
+
+#ifdef __cplusplus
+}
+#endif
+#endif //DirPatch_dir_patch_types_h