react-native-update 10.34.2 → 10.34.4

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

@@ -0,0 +1,236 @@
+// 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"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#include "../../libHDiffPatch/HPatch/checksum_plugin.h"
+#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;
+    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(const hpatch_TStreamInput* diffFile,TDirDiffInfo* out_info);
+hpatch_BOOL getDirDiffInfoByFile(const char* diffFileName,TDirDiffInfo* out_info,
+                                 hpatch_StreamPos_t diffDataOffert,hpatch_StreamPos_t diffDataSize);
+static hpatch_inline
+hpatch_BOOL getIsDirDiffFile(const char* diffFileName){
+     TDirDiffInfo dirDiffInfo;
+    if (!getDirDiffInfoByFile(diffFileName,&dirDiffInfo,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 TDirPatchChecksumSet{
+        hpatch_TChecksum*   checksumPlugin;
+        hpatch_BOOL         isCheck_oldRefData;
+        hpatch_BOOL         isCheck_newRefData;  
+        hpatch_BOOL         isCheck_copyFileData;
+        hpatch_BOOL         isCheck_dirDiffData;
+    } TDirPatchChecksumSet;
+    
+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;
+    char*                       _oldRootDir;
+    char*                       _oldRootDir_end;
+    char*                       _oldRootDir_bufEnd;
+    void*                       _pOldRefMem;
+    
+    hpatch_ICopyDataListener    _sameFileCopyListener;
+    
+    TDirPatchChecksumSet        _checksumSet;
+    unsigned char*              _pChecksumMem;
+    
+    hpatch_TDecompress*         _decompressPlugin;
+    const hpatch_TStreamInput*  _dirDiffData;
+    void*                       _pDiffDataMem;
+    size_t*                     _pOldSameRefCount;
+} 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_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);
+    
+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(TDirPatcher* self,size_t newExecuteIndex)
+    { return TNewDirOutput_getNewExecuteFileByIndex(&self->_newDir,newExecuteIndex); }
+
+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(TDirPatcher* self,size_t oldPathIndex);
+const char* TDirPatcher_getOldRefPathByRefIndex(TDirPatcher* self,size_t oldRefIndex);
+const char* TDirPatcher_getOldPathByNewPath(TDirPatcher* self,const char* newPath);
+static hpatch_inline const char* TDirPatcher_getNewPathRoot(TDirPatcher* self)
+    { return TNewDirOutput_getNewPathRoot(&self->_newDir); }
+static hpatch_inline const char* TDirPatcher_getNewPathByIndex(TDirPatcher* self,size_t newPathIndex)
+    { return TNewDirOutput_getNewPathByIndex(&self->_newDir,newPathIndex); }
+static hpatch_inline const char* TDirPatcher_getOldPathBySameIndex(TDirPatcher* self,size_t sameIndex)
+    { return TNewDirOutput_getOldPathBySameIndex(&self->_newDir,sameIndex); }
+static hpatch_inline const char* TDirPatcher_getNewPathBySameIndex(TDirPatcher* self,size_t sameIndex)
+    { return TNewDirOutput_getNewPathBySameIndex(&self->_newDir,sameIndex); }
+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;
+}
+
+static hpatch_inline
+const char* TDirPatcher_getOldExecuteFileByNewExecuteIndex(TDirPatcher* self,size_t newExecuteIndex){
+    const char* executeFileName_in_new=TDirPatcher_getNewExecuteFileByIndex(self,newExecuteIndex);
+    return TDirPatcher_getOldPathByNewPath(self,executeFileName_in_new);
+}
+
+
+hpatch_BOOL TDirPatcher_initOldSameRefCount(TDirPatcher* self);
+void        TDirPatcher_finishOldSameRefCount(TDirPatcher* self);
+const char* TDirPatcher_getOldPathBySameIndex(TDirPatcher* self,size_t sameIndex);
+const char* TDirPatcher_getNewPathBySameIndex(TDirPatcher* self,size_t sameIndex);
+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  check(value) { if (!(value)){ fprintf(stderr,"check "#value" 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) {
+        check(_TStreamCacheClip_unpackUIntWithTag(sclip,&out_list[i],0));
+    }
+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;
+        check(_TStreamCacheClip_unpackUIntWithTag(sclip,&incValue,0));
+        backValue+=1+incValue;
+        check(backValue<check_endValue);
+        out_list[i]=(size_t)backValue;
+    }
+clear:
+    return result;
+}
+
+char* setPath(char* out_path,char* out_pathBufEnd,const char* fileName){
+    char* result=0; //false
+    size_t strLen=strlen(fileName);
+    check(strLen+1<=(size_t)(out_pathBufEnd-out_path));
+    memcpy(out_path,fileName,strLen+1);//with '\0'
+    result=out_path+strLen;
+clear:
+    return result;
+}
+
+char* setDirPath(char* out_path,char* out_pathBufEnd,const char* dirName){
+    char* result=0; //false
+    size_t strLen=strlen(dirName);
+    hpatch_BOOL isNeedDirSeparator=(strLen>0)&&(dirName[strLen-1]!=kPatch_dirSeparator);
+    check((strLen+(isNeedDirSeparator?1:0)+1)<=(size_t)(out_pathBufEnd-out_path));
+    memcpy(out_path,dirName,strLen);
+    result=out_path+strLen;
+    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,53 @@
+// 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);
+    
+    //return path end pos
+    char* setPath(char* out_path,char* out_pathBufEnd,const char* fileName);
+    char* setDirPath(char* out_path,char* out_pathBufEnd,const char* dirName);
+
+    
+#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,61 @@
+// 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
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#   define kMaxOpenFileNumber_limit_min          4
+#   define kMaxOpenFileNumber_default_min        8 //must >= limit_min
+#   define kMaxOpenFileNumber_default_diff      48
+#   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