react-native-update 10.34.2 → 10.34.3

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/diff.h

@@ -0,0 +1,201 @@
+//diff.h
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2018 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 or substantial portions 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_diff_h
+#define HDiff_diff_h
+#include <vector>
+#include "diff_types.h"
+
+static const int kMinSingleMatchScore_default = 6;
+
+//create a diff data between oldData and newData
+//  out_diff is uncompressed, you can use create_compressed_diff()
+//       or create_single_compressed_diff() create compressed diff data
+//  kMinSingleMatchScore: default 6, bin: 0--4  text: 4--9
+//  isUseBigCacheMatch: big cache max used O(oldSize) memory, match speed faster, but build big cache slow 
+//  NOTE: create_diff() + patch() or patch_stream() or patch_stream_with_cache() is no longer recommended,
+//    recommend change to use  create_single_compressed_diff() + patch_single_stream() or patch_single_compressed_diff()
+void create_diff(const unsigned char* newData,const unsigned char* newData_end,
+                 const unsigned char* oldData,const unsigned char* oldData_end,
+                 std::vector<unsigned char>& out_diff,
+                 int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                 bool isUseBigCacheMatch=false,size_t threadNum=1);
+
+//return patch(oldData+diff)==newData?
+bool check_diff(const unsigned char* newData,const unsigned char* newData_end,
+                const unsigned char* oldData,const unsigned char* oldData_end,
+                const unsigned char* diff,const unsigned char* diff_end);
+bool check_diff(const hpatch_TStreamInput*  newData,
+                const hpatch_TStreamInput*  oldData,
+                const hpatch_TStreamInput*  diff);
+
+
+
+
+//create a compressed diff data between oldData and newData
+//  out_diff compressed by compressPlugin
+//  recommended always use create_single_compressed_diff() replace create_compressed_diff()
+//  kMinSingleMatchScore: default 6, bin: 0--4  text: 4--9
+//  isUseBigCacheMatch: big cache max used O(oldSize) memory, match speed faster, but build big cache slow 
+void create_compressed_diff(const unsigned char* newData,const unsigned char* newData_end,
+                            const unsigned char* oldData,const unsigned char* oldData_end,
+                            std::vector<unsigned char>& out_diff,
+                            const hdiff_TCompress* compressPlugin=0,
+                            int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                            bool isUseBigCacheMatch=false,
+                            ICoverLinesListener* listener=0,size_t threadNum=1);
+void create_compressed_diff(const unsigned char* newData,const unsigned char* newData_end,
+                            const unsigned char* oldData,const unsigned char* oldData_end,
+                            const hpatch_TStreamOutput* out_diff,
+                            const hdiff_TCompress* compressPlugin=0,
+                            int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                            bool isUseBigCacheMatch=false,
+                            ICoverLinesListener* listener=0,size_t threadNum=1);
+
+//create a compressed diff data by stream:
+//  can control memory requires and run speed by different kMatchBlockSize value,
+//      but out_diff size is larger than create_compressed_diff()
+//  recommended used in limited environment or support large file
+//  recommended always use create_single_compressed_diff_stream() replace create_compressed_diff_stream()
+//  kMatchBlockSize: recommended (1<<4)--(1<<14)
+//    if increase kMatchBlockSize then run faster and require less memory, but out_diff size increase
+//  NOTICE: out_diff->write()'s writeToPos may be back to update headData!
+//  throw std::runtime_error when I/O error,etc.
+static const size_t kMatchBlockSize_default = (1<<6);
+static const size_t kMatchBlockSize_min=4;
+void create_compressed_diff_stream(const hpatch_TStreamInput*  newData,
+                                   const hpatch_TStreamInput*  oldData,
+                                   const hpatch_TStreamOutput* out_diff,
+                                   const hdiff_TCompress* compressPlugin=0,
+                                   size_t kMatchBlockSize=kMatchBlockSize_default,
+                                   const hdiff_TMTSets_s* mtsets=0);
+
+//return patch_decompress(oldData+diff)==newData?
+bool check_compressed_diff(const unsigned char* newData,const unsigned char* newData_end,
+                           const unsigned char* oldData,const unsigned char* oldData_end,
+                           const unsigned char* diff,const unsigned char* diff_end,
+                           hpatch_TDecompress* decompressPlugin);
+bool check_compressed_diff(const hpatch_TStreamInput*  newData,
+                           const hpatch_TStreamInput*  oldData,
+                           const hpatch_TStreamInput*  compressed_diff,
+                           hpatch_TDecompress* decompressPlugin);
+// check_compressed_diff_stream rename to check_compressed_diff
+
+//resave compressed_diff
+//  decompress in_diff and recompress to out_diff
+//  throw std::runtime_error when input file error or I/O error,etc.
+void resave_compressed_diff(const hpatch_TStreamInput*  in_diff,
+                            hpatch_TDecompress*         decompressPlugin,
+                            const hpatch_TStreamOutput* out_diff,
+                            const hdiff_TCompress*      compressPlugin,
+                            hpatch_StreamPos_t          out_diff_curPos=0);
+
+
+
+
+static const size_t kDefaultPatchStepMemSize =1024*256;
+
+//create a diff data between oldData and newData, the diffData saved as single compressed stream
+//  kMinSingleMatchScore: default 6, bin: 0--4  text: 4--9
+//  patchStepMemSize>=hpatch_kStreamCacheSize, default 256k, recommended 64k,2m etc...
+//  isUseBigCacheMatch: big cache max used O(oldSize) memory, match speed faster, but build big cache slow 
+void create_single_compressed_diff(const unsigned char* newData,const unsigned char* newData_end,
+                                   const unsigned char* oldData,const unsigned char* oldData_end,
+                                   std::vector<unsigned char>& out_diff,const hdiff_TCompress* compressPlugin=0,
+                                   int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                                   size_t patchStepMemSize=kDefaultPatchStepMemSize,
+                                   bool isUseBigCacheMatch=false,
+                                   ICoverLinesListener* listener=0,size_t threadNum=1);
+void create_single_compressed_diff(const unsigned char* newData,const unsigned char* newData_end,
+                                   const unsigned char* oldData,const unsigned char* oldData_end,
+                                   const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin=0,
+                                   int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                                   size_t patchStepMemSize=kDefaultPatchStepMemSize,
+                                   bool isUseBigCacheMatch=false,
+                                   ICoverLinesListener* listener=0,size_t threadNum=1);
+//create single compressed diff data by stream:
+//  can control memory requires and run speed by different kMatchBlockSize value,
+//      but out_diff size is larger than create_single_compressed_diff()
+//  recommended used in limited environment or support large file
+//  kMatchBlockSize: recommended (1<<4)--(1<<14)
+//    if increase kMatchBlockSize then run faster and require less memory, but out_diff size increase
+//  NOTICE: out_diff->write()'s writeToPos may be back to update headData!
+//  throw std::runtime_error when I/O error,etc.
+void create_single_compressed_diff_stream(const hpatch_TStreamInput*  newData,
+                                          const hpatch_TStreamInput*  oldData,
+                                          const hpatch_TStreamOutput* out_diff,
+                                          const hdiff_TCompress* compressPlugin=0,
+                                          size_t kMatchBlockSize=kMatchBlockSize_default,
+                                          size_t patchStepMemSize=kDefaultPatchStepMemSize,
+                                          const hdiff_TMTSets_s* mtsets=0);
+
+//return patch_single_?(oldData+diff)==newData?
+bool check_single_compressed_diff(const unsigned char* newData,const unsigned char* newData_end,
+                                  const unsigned char* oldData,const unsigned char* oldData_end,
+                                  const unsigned char* diff,const unsigned char* diff_end,
+                                  hpatch_TDecompress* decompressPlugin,size_t threadNum=1);
+bool check_single_compressed_diff(const hpatch_TStreamInput* newData,
+                                  const hpatch_TStreamInput* oldData,
+                                  const hpatch_TStreamInput* diff,
+                                  hpatch_TDecompress* decompressPlugin,size_t threadNum=1);
+
+//resave single_compressed_diff
+//  decompress in_diff and recompress to out_diff
+//  throw std::runtime_error when input file error or I/O error,etc.
+//  return new out_diff curPos
+hpatch_StreamPos_t
+     resave_single_compressed_diff(const hpatch_TStreamInput*  in_diff,
+                                   hpatch_TDecompress*         decompressPlugin,
+                                   const hpatch_TStreamOutput* out_diff,
+                                   const hdiff_TCompress*      compressPlugin,
+                                   const hpatch_singleCompressedDiffInfo* diffInfo=0,
+                                   hpatch_StreamPos_t          in_diff_curPos=0,
+                                   hpatch_StreamPos_t          out_diff_curPos=0);
+
+
+//same as create?compressed_diff_stream(), but not serialize diffData, only got covers
+void get_match_covers_by_block(const hpatch_TStreamInput* newData,const hpatch_TStreamInput* oldData,
+                               hpatch_TOutputCovers* out_covers,size_t kMatchBlockSize,const hdiff_TMTSets_s* mtsets);
+void get_match_covers_by_block(const unsigned char* newData,const unsigned char* newData_end,
+                               const unsigned char* oldData,const unsigned char* oldData_end,
+                               hpatch_TOutputCovers* out_covers,size_t kMatchBlockSize,size_t threadNum);
+
+//same as create?_diff(), but not serialize diffData, only got covers
+void get_match_covers_by_sstring(const unsigned char* newData,const unsigned char* newData_end,
+                                 const unsigned char* oldData,const unsigned char* oldData_end,
+                                 hpatch_TOutputCovers* out_covers,
+                                 int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                                 bool isUseBigCacheMatch=false,ICoverLinesListener* listener=0,
+                                 size_t threadNum=1,bool isCanExtendCover=true);
+void get_match_covers_by_sstring(const unsigned char* newData,const unsigned char* newData_end,
+                                 const unsigned char* oldData,const unsigned char* oldData_end,
+                                 std::vector<hpatch_TCover_sz>& out_covers,
+                                 int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                                 bool isUseBigCacheMatch=false,ICoverLinesListener* listener=0,
+                                 size_t threadNum=1,bool isCanExtendCover=true);
+#endif

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/diff_for_hpatch_lite.h

@@ -0,0 +1,74 @@
+//diff_for_hpatch_lite.h
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2020-2022 HouSisong All Rights Reserved.
+ */
+
+#ifndef HDiff_for_hpatch_lite_h
+#define HDiff_for_hpatch_lite_h
+#include "diff_types.h"
+#include "../HPatchLite/hpatch_lite_types.h"
+#include <vector>
+
+struct ILiteDiffListener:public ICoverLinesListener{
+    bool (*getInplacePatchExtraSafeSize)(ILiteDiffListener* listener,hpi_size_t* out_extraSafeSize); //if NULL, default is false;
+};
+
+struct hdiffi_TCompress{
+    const hdiff_TCompress* compress;
+    hpi_compressType       compress_type;
+};
+const int kLiteMatchScore_default = 6;
+
+void create_lite_diff(const hpi_byte* newData,const hpi_byte* newData_end,
+                      const hpi_byte* oldData,const hpi_byte* oldData_end,
+                      std::vector<hpi_byte>& out_lite_diff,const hdiffi_TCompress* compressPlugin,
+                      int kMinSingleMatchScore=kLiteMatchScore_default,bool isUseBigCacheMatch=false,
+                      ILiteDiffListener* listener=0,size_t threadNum=1);
+
+bool check_lite_diff_open(const hpi_byte* lite_diff,const hpi_byte* lite_diff_end,
+                          hpi_compressType* out_compress_type);
+bool check_lite_diff(const hpi_byte* newData,const hpi_byte* newData_end,
+                     const hpi_byte* oldData,const hpi_byte* oldData_end,
+                     const hpi_byte* lite_diff,const hpi_byte* lite_diff_end,
+                     hpatch_TDecompress* decompressPlugin);
+
+
+typedef struct TInplaceSets{
+    size_t      extraSafeSize;          //extra memory for inplace-patch; patch used sum memory size=extraSafeSize+decompressMemSize+cacheSize;
+    bool        isCompatibleLiteDiff;   //default is false; if true, diff_data compatible with create_lite_diff() format; if true, diff_data as a new format saved extraSafeSize;
+    bool        isCanExtendCover;       //now always is true
+} TInplaceSets;
+static inline bool isInplaceASets(const TInplaceSets& sets) { return sets.extraSafeSize==0; }
+static inline bool isInplaceBSets(const TInplaceSets& sets) { return sets.extraSafeSize>0; }
+
+//create a diff(delta) data for inplace-patch; 
+void create_inplace_lite_diff(const hpi_byte* newData,const hpi_byte* newData_end,
+                              const hpi_byte* oldData,const hpi_byte* oldData_end,
+                              std::vector<hpi_byte>& out_inplace_lite_diff,const TInplaceSets& inplaceSets,
+                              const hdiffi_TCompress* compressPlugin,int kMinSingleMatchScore=kLiteMatchScore_default,
+                              bool isUseBigCacheMatch=false,size_t threadNum=1);
+
+static inline //inplaceA format, a very simplified diffFile format;
+void create_inplaceA_lite_diff(const hpi_byte* newData,const hpi_byte* newData_end,
+                               const hpi_byte* oldData,const hpi_byte* oldData_end,
+                               std::vector<hpi_byte>& out_inplace_lite_diff,
+                               const hdiffi_TCompress* compressPlugin,int kMinSingleMatchScore=kLiteMatchScore_default,
+                               bool isUseBigCacheMatch=false,size_t threadNum=1){
+    const TInplaceSets kInplaceASets={0,false,true};
+    create_inplace_lite_diff(newData,newData_end,oldData,oldData_end,out_inplace_lite_diff,kInplaceASets,
+                             compressPlugin,kMinSingleMatchScore,isUseBigCacheMatch,threadNum);
+}
+static inline //inplaceB format, enable extra space(memory or disk);
+void create_inplaceB_lite_diff(const hpi_byte* newData,const hpi_byte* newData_end,
+                               const hpi_byte* oldData,const hpi_byte* oldData_end,
+                               std::vector<hpi_byte>& out_inplace_lite_diff,size_t extraSafeSize,
+                               const hdiffi_TCompress* compressPlugin,int kMinSingleMatchScore=kLiteMatchScore_default,
+                               bool isUseBigCacheMatch=false,size_t threadNum=1){
+    const TInplaceSets kInplaceBSets={extraSafeSize,false,true};
+    create_inplace_lite_diff(newData,newData_end,oldData,oldData_end,out_inplace_lite_diff,kInplaceBSets,
+                             compressPlugin,kMinSingleMatchScore,isUseBigCacheMatch,threadNum);
+}
+
+#endif //HDiff_for_hpatch_lite_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/diff_types.h

@@ -0,0 +1,187 @@
+//diff_types.h
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2017 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 or substantial portions 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_diff_types_h
+#define HDiff_diff_types_h
+#include "../HPatch/patch_types.h"
+#include <stdexcept> //std::runtime_error
+#include <utility> //std::pair
+
+#ifndef _IS_OUT_DIFF_INFO
+#   define  _IS_OUT_DIFF_INFO   1
+#endif
+#if (_IS_OUT_DIFF_INFO)
+extern int _hdiff_is_out_diff_info;
+#  define   _out_diff_info(...)  do{ if (_hdiff_is_out_diff_info) printf(__VA_ARGS__); } while(0)
+#else
+#  define   _out_diff_info(...)
+#endif
+
+#define hdiff_kFileIOBufBestSize (1024*512)
+namespace hdiff_private{
+
+    template<class TCover>
+    struct cover_cmp_by_new_t{
+        inline bool operator ()(const TCover& x,const TCover& y){
+            if (x.newPos!=y.newPos)
+                return x.newPos<y.newPos;
+            else
+                return x.length<y.length;
+        }
+    };
+    template<class TCover>
+    struct cover_cmp_by_old_t{
+        inline bool operator ()(const TCover& x,const TCover& y){
+            if (x.oldPos!=y.oldPos)
+                return x.oldPos<y.oldPos;
+            else
+                return x.length<y.length;
+        }
+    };
+    template<class TCover>
+    inline static bool cover_is_collinear(const TCover& x,const TCover& y){
+        return (x.oldPos+y.newPos==x.newPos+y.oldPos);
+    }
+
+    static const int kCoverMinMatchLen=5;
+
+
+    // TRefCovers: a tools for diff listener,read TCover array;
+    struct TRefCovers{
+        inline TRefCovers(const void* pcovers_,size_t coverCount_,bool isCover32_)
+        :pcovers(pcovers_),coverCount(coverCount_),isCover32(isCover32_){}
+        inline TRefCovers(const hpatch_TCover* pcovers_,size_t coverCount_)
+        :pcovers(pcovers_),coverCount(coverCount_),isCover32(false){}
+        inline hpatch_TCover operator[](size_t index)const{
+            if (isCover32){
+                const hpatch_TCover32& cover=((const hpatch_TCover32*)pcovers)[index];  
+                hpatch_TCover result={cover.oldPos,cover.newPos,cover.length}; 
+                return result; 
+            }else{
+                return ((const hpatch_TCover*)pcovers)[index]; 
+            }
+        }
+        inline size_t size()const{  return coverCount; }
+    private:
+        const void*     pcovers;
+        const size_t    coverCount;
+        const bool      isCover32;
+    };
+}
+
+    //return whether x&y's datas are equal; if read stream fail,thorw std::runtime_error
+    hpatch_BOOL hdiff_streamDataIsEqual(const hpatch_TStreamInput* x,const hpatch_TStreamInput* y);
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    typedef hpatch_TStreamOutput hdiff_TStreamOutput;
+    typedef hpatch_TStreamInput  hdiff_TStreamInput;
+    //compress plugin
+    typedef struct hdiff_TCompress{
+        //return type tag; strlen(result)<=hpatch_kMaxPluginTypeLength; (Note:result lifetime)
+        const char*             (*compressType)(void);//ascii cstring,cannot contain '&'
+        //return the max compressed size, if input dataSize data;
+        hpatch_StreamPos_t (*maxCompressedSize)(hpatch_StreamPos_t dataSize);
+        //return support threadNumber
+        int          (*setParallelThreadNumber)(struct hdiff_TCompress* compressPlugin,int threadNum);
+        //compress data to out_code; return compressed size, if error or not need compress then return 0;
+        //if out_code->write() return hdiff_stream_kCancelCompress(error) then return 0;
+        //if memory I/O can use hdiff_compress_mem()
+        hpatch_StreamPos_t          (*compress)(const struct hdiff_TCompress* compressPlugin,
+                                                const hpatch_TStreamOutput*   out_code,
+                                                const hpatch_TStreamInput*    in_data);
+        const char*        (*compressTypeForDisplay)(void);//like compressType but just for display,can NULL
+    } hdiff_TCompress;
+    
+    static hpatch_inline
+    size_t hdiff_compress_mem(const hdiff_TCompress* compressPlugin,
+                              unsigned char* out_code,unsigned char* out_code_end,
+                              const unsigned char* data,const unsigned char* data_end){
+        hpatch_TStreamOutput codeStream;
+        hpatch_TStreamInput  dataStream;
+        mem_as_hStreamOutput(&codeStream,out_code,out_code_end);
+        mem_as_hStreamInput(&dataStream,data,data_end);
+        hpatch_StreamPos_t codeLen=compressPlugin->compress(compressPlugin,&codeStream,&dataStream);
+        if (codeLen!=(size_t)codeLen) return 0; //error
+        return (size_t)codeLen;
+    }
+
+    
+    struct IDiffSearchCoverListener{
+        bool (*limitCover)(struct IDiffSearchCoverListener* listener,
+                           const hpatch_TCover* cover,hpatch_StreamPos_t* out_leaveLen);
+        void (*limitCover_front)(struct IDiffSearchCoverListener* listener,
+                                 const hpatch_TCover* front_cover,hpatch_StreamPos_t* out_leaveLen);
+    };
+    struct IDiffResearchCover{
+        void (*researchCover)(struct IDiffResearchCover* diffi,struct IDiffSearchCoverListener* listener,size_t limitCoverIndex,
+                              hpatch_StreamPos_t sameCover_endPosBack,hpatch_StreamPos_t hitPos,hpatch_StreamPos_t hitLen);
+    };
+    struct IDiffInsertCover{
+        void* (*insertCover)(IDiffInsertCover* diffi,const void* pInsertCovers,size_t insertCoverCount,bool insertIsCover32);
+    };
+
+    static const int kDefaultMaxMatchDeepForLimit=6;
+    typedef struct{
+        hpatch_StreamPos_t beginPos;
+        hpatch_StreamPos_t endPos;
+    } hdiff_TRange;
+
+    struct ICoverLinesListener {
+        bool (*search_cover_limit)(ICoverLinesListener* listener,const void* pcovers,size_t coverCount,bool isCover32);
+        void (*research_cover)(ICoverLinesListener* listener,IDiffResearchCover* diffi,const void* pcovers,size_t coverCount,bool isCover32);
+        void (*insert_cover)(ICoverLinesListener* listener,IDiffInsertCover* diffi,void* pcovers,size_t coverCount,bool isCover32,
+                             hpatch_StreamPos_t* newSize,hpatch_StreamPos_t* oldSize);
+        void (*search_cover_finish)(ICoverLinesListener* listener,void* pcovers,size_t* pcoverCount,bool isCover32,
+                                    hpatch_StreamPos_t* newSize,hpatch_StreamPos_t* oldSize);
+        int (*get_max_match_deep)(const ICoverLinesListener* listener); //if null, default kDefaultMaxMatchDeepForLimit
+        // *search_block* for multi-thread parallel match,can null
+        void (*begin_search_block)(ICoverLinesListener* listener,hpatch_StreamPos_t newSize,
+                                   size_t searchBlockSize,size_t kPartPepeatSize);
+        hpatch_BOOL (*next_search_block_MT)(ICoverLinesListener* listener,hdiff_TRange* out_newRange);//must thread safe
+        hpatch_StreamPos_t (*get_limit_cover_length)(const ICoverLinesListener* listener); //if null, default kDefaultLimitCoverLen 
+        void (*map_streams_befor_serialize)(ICoverLinesListener* listener,const hpatch_TStreamInput** pnewData,const hpatch_TStreamInput** poldData);
+    };
+
+    struct hdiff_TMTSets_s{ // used by $hdiff -s
+        size_t threadNum;
+        size_t threadNumForSearch; // NOTE: multi-thread search need frequent random disk read
+        bool   newDataIsMTSafe;
+        bool   oldDataIsMTSafe;
+    };
+
+    static const hdiff_TMTSets_s hdiff_TMTSets_s_kEmpty={1,1,false,false};
+    
+
+#ifdef __cplusplus
+}
+#endif
+#endif //HDiff_diff_types_h