react-native-update 10.34.3 → 10.34.4

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

@@ -35,76 +35,75 @@ 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
+//       or create_compressed_diff_stream() create compressed diff data
+//  recommended always use create_compressed_diff() replace create_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 
-//  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);
+                 int kMinSingleMatchScore=kMinSingleMatchScore_default);
 
 //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
+//create a compressed diffData 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);
+                            int kMinSingleMatchScore=kMinSingleMatchScore_default);
+//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);
+
+//see check_compressed_diff
+bool check_compressed_diff_stream(const hpatch_TStreamInput*  newData,
+                                  const hpatch_TStreamInput*  oldData,
+                                  const hpatch_TStreamInput*  compressed_diff,
+                                  hpatch_TDecompress* decompressPlugin);
+
+struct ICoverLinesListener {
+    void (*coverLines)(ICoverLinesListener* listener,hpatch_TCover* out_covers,size_t* coverCount,
+                       hpatch_StreamPos_t* newSize,hpatch_StreamPos_t* oldSize);
+};
+const size_t kDefaultStepMemSize =1024*256;
+
+//create a diffData between oldData and newData, the diffData saved as single compressed stream
+//  still under development!
+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,ICoverLinesListener* listener=0,
+                                   const hdiff_TCompress* compressPlugin=0,int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                                   size_t patchStepMemSize=kDefaultStepMemSize,bool _is_test_search_cover_by_stream=false);
+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);
+
 
-//create a compressed diff data by stream:
+//diff 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);
+                                   size_t kMatchBlockSize=kMatchBlockSize_default);
 
-//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
@@ -112,90 +111,6 @@ bool check_compressed_diff(const hpatch_TStreamInput*  newData,
 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);
+                            const hdiff_TCompress*      compressPlugin);
 
-//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_types.h

@@ -29,73 +29,6 @@
 #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"
@@ -118,7 +51,6 @@ extern "C"
         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
@@ -133,54 +65,7 @@ extern "C"
         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