react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HPatch/patch.h

@@ -29,40 +29,23 @@
 #ifndef HPatch_patch_h
 #define HPatch_patch_h
 #include "patch_types.h"
-#include "hpatch_mt/hpatch_mt.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-//all patch*() functions do not allocate memory
-
-//optimize speed for patch_stream_with_cache() & patch_decompress_with_cache() 
-//      & patch_single_stream(),patch_single_compressed_diff(),patch_single_stream_diff():
-//  preload part of oldData into cache,
-//  cache memory size (temp_cache_end-temp_cache) the larger the better for large oldData file
-#ifndef _IS_NEED_CACHE_OLD_BY_COVERS
-#   define _IS_NEED_CACHE_OLD_BY_COVERS     1
-#endif
-#ifndef _IS_NEED_CACHE_OLD_ALL
-#   define _IS_NEED_CACHE_OLD_ALL           1
-#endif
-
+//  all patch*() functions do not allocate memory
 
 //generate newData by patch(oldData + serializedDiff)
 //  serializedDiff create by create_diff()
-//  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()
 hpatch_BOOL patch(unsigned char* out_newData,unsigned char* out_newData_end,
                   const unsigned char* oldData,const unsigned char* oldData_end,
                   const unsigned char* serializedDiff,const unsigned char* serializedDiff_end);
 
 //patch by stream, see patch()
 //  used (hpatch_kStreamCacheSize*8 stack memory) for I/O cache
-//  if use patch_stream_with_cache(), can passing larger memory cache to optimize speed
+//  if use patch_stream_with_cache(), can passing more memory for I/O cache to optimize speed
 //  serializedDiff create by create_diff()
-//  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()
 hpatch_BOOL patch_stream(const hpatch_TStreamOutput* out_newData,       //sequential write
                          const hpatch_TStreamInput*  oldData,           //random read
                          const hpatch_TStreamInput*  serializedDiff);   //random read
@@ -70,16 +53,12 @@ hpatch_BOOL patch_stream(const hpatch_TStreamOutput* out_newData,       //sequen
 //see patch_stream()
 //  can passing more memory for I/O cache to optimize speed
 //  note: (temp_cache_end-temp_cache)>=2048
-//  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()
 hpatch_BOOL patch_stream_with_cache(const hpatch_TStreamOutput* out_newData,    //sequential write
                                     const hpatch_TStreamInput*  oldData,        //random read
                                     const hpatch_TStreamInput*  serializedDiff, //random read
                                     unsigned char* temp_cache,unsigned char* temp_cache_end);
 
 
-
-
 //get compressedDiff info
 //  compressedDiff created by create_compressed_diff() or create_compressed_diff_stream()
 hpatch_BOOL getCompressedDiffInfo(hpatch_compressedDiffInfo* out_diffInfo,
@@ -93,9 +72,10 @@ hpatch_inline static hpatch_BOOL
         mem_as_hStreamInput(&diffStream,compressedDiff,compressedDiff_end);
         return getCompressedDiffInfo(out_diffInfo,&diffStream);
     }
+
     
 //patch with decompress plugin
-//  used (hpatch_kStreamCacheSize*6 stack memory) + (decompress buffer*4)
+//  used (hpatch_kStreamCacheSize*6 stack memory) + (decompress memory*4)
 //  compressedDiff create by create_compressed_diff() or create_compressed_diff_stream()
 //  decompressPlugin can null when no compressed data in compressedDiff
 //  if use patch_decompress_with_cache(), can passing larger memory cache to optimize speed
@@ -104,6 +84,13 @@ hpatch_BOOL patch_decompress(const hpatch_TStreamOutput* out_newData,       //se
                              const hpatch_TStreamInput*  compressedDiff,    //random read
                              hpatch_TDecompress* decompressPlugin);
 
+
+//ON: for patch_decompress_with_cache(), preparatory load part of oldData into cache,
+//  cache memory size (temp_cache_end-temp_cache) the larger the better for large oldData file
+#ifndef _IS_NEED_CACHE_OLD_BY_COVERS
+#   define _IS_NEED_CACHE_OLD_BY_COVERS 1
+#endif
+
 //see patch_decompress()
 //  can passing larger memory cache to optimize speed
 //  note: (temp_cache_end-temp_cache)>=2048
@@ -127,24 +114,18 @@ hpatch_inline static hpatch_BOOL
         mem_as_hStreamInput(&diffStream,compressedDiff,compressedDiff_end);
         return patch_decompress(&out_newStream,&oldStream,&diffStream,decompressPlugin);
     }
-
-
-
-
-// hpatch_TCoverList: open diffData and read coverList
+    
     typedef struct hpatch_TCoverList{
         hpatch_TCovers* ICovers;
     //private:
         unsigned char _buf[hpatch_kStreamCacheSize*4];
     } hpatch_TCoverList;
-
+    
 hpatch_inline static
 void        hpatch_coverList_init(hpatch_TCoverList* coverList) {
                                   assert(coverList!=0); memset(coverList,0,sizeof(*coverList)-sizeof(coverList->_buf)); }
-//  serializedDiff create by create_diff()
 hpatch_BOOL hpatch_coverList_open_serializedDiff(hpatch_TCoverList*         out_coverList,
                                                  const hpatch_TStreamInput* serializedDiff);
-//  compressedDiff create by create_compressed_diff() or create_compressed_diff_stream()
 hpatch_BOOL hpatch_coverList_open_compressedDiff(hpatch_TCoverList*         out_coverList,
                                                  const hpatch_TStreamInput* compressedDiff,
                                                  hpatch_TDecompress*        decompressPlugin);
@@ -155,96 +136,77 @@ hpatch_BOOL hpatch_coverList_close(hpatch_TCoverList* coverList) {
                                        result=coverList->ICovers->close(coverList->ICovers);
                                        hpatch_coverList_init(coverList); } return result; }
 
-
-//patch singleCompressedDiff with listener
-//	used (stepMemSize memory) + (I/O cache memory) + (decompress buffer*1)
-//  every byte in singleCompressedDiff will only be read once in order
-//  singleCompressedDiff create by create_single_compressed_diff() or create_single_compressed_diff_stream() or create_hdiff_by_sign()
-//  you can download&patch diffData at the same time, without saving it to disk
-//  same as call getSingleCompressedDiffInfo() + listener->onDiffInfo() + patch_single_compressed_diff()
-static hpatch_force_inline
-hpatch_BOOL patch_single_stream(sspatch_listener_t* listener, //call back when got diffInfo
-                                const hpatch_TStreamOutput* out_newData,          //sequential write
-                                const hpatch_TStreamInput*  oldData,              //random read
-                                const hpatch_TStreamInput*  singleCompressedDiff, //sequential read every byte
-                                hpatch_StreamPos_t  diffInfo_pos, //default 0, begin pos in singleCompressedDiff
-                                sspatch_coversListener_t* coversListener, //default NULL, call by on got some covers
-                                size_t threadNum){ // 1..5; if >1, multi-thread for I/O & decompress etc.
-        return _patch_single_stream_mt(listener,out_newData,oldData,singleCompressedDiff,
-                                        diffInfo_pos,coversListener,threadNum,hpatchMTSets_full);  
-    }
-static hpatch_force_inline
-hpatch_BOOL patch_single_stream_mem(sspatch_listener_t* listener,
-                                    unsigned char* out_newData,unsigned char* out_newData_end,
-                                    const unsigned char* oldData,const unsigned char* oldData_end,
-                                    const unsigned char* diff,const unsigned char* diff_end,
-                                    sspatch_coversListener_t* coversListener,size_t threadNum){
-        hpatch_TStreamOutput out_newStream;
-        hpatch_TStreamInput  oldStream;
-        hpatch_TStreamInput  diffStream;
-        const hpatchMTSets_t hpatchMTSets={0,0,0,1}; //all data in mem, I/O not need MT
-        mem_as_hStreamOutput(&out_newStream,out_newData,out_newData_end);
-        mem_as_hStreamInput(&oldStream,oldData,oldData_end);
-        mem_as_hStreamInput(&diffStream,diff,diff_end);
-        return _patch_single_stream_mt(listener,&out_newStream,&oldStream,&diffStream,0,coversListener,
-                                       threadNum,hpatchMTSets);
-    }
-
-//get singleCompressedDiff info
-//  singleCompressedDiff create by create_single_compressed_diff() or create_single_compressed_diff_stream() or create_hdiff_by_sign()
-hpatch_BOOL getSingleCompressedDiffInfo(hpatch_singleCompressedDiffInfo* out_diffInfo,
-                                        const hpatch_TStreamInput*  singleCompressedDiff,   //sequential read
-                                        hpatch_StreamPos_t diffInfo_pos//default 0, begin pos in singleCompressedDiff
-                                        );
-static hpatch_force_inline
-hpatch_BOOL getSingleCompressedDiffInfo_mem(hpatch_singleCompressedDiffInfo* out_diffInfo,
-                                            const unsigned char* singleCompressedDiff,
-                                            const unsigned char* singleCompressedDiff_end){
-        hpatch_TStreamInput  diffStream;
-        mem_as_hStreamInput(&diffStream,singleCompressedDiff,singleCompressedDiff_end);
-        return getSingleCompressedDiffInfo(out_diffInfo,&diffStream,0);            
-    }
-
-
-//patch singleCompressedDiff with diffInfo
-//	used (stepMemSize memory) + (I/O cache memory) + (decompress buffer*1)
-//	note: (I/O cache memory) >= hpatch_kStreamCacheSize*3
-//  temp_cache_end-temp_cache == stepMemSize + (I/O cache memory)
-//  singleCompressedDiff create by create_single_compressed_diff() or create_single_compressed_diff_stream() or create_hdiff_by_sign()
-//  decompressPlugin can null when no compressed data in singleCompressedDiff
-//  same as call compressed_stream_as_uncompressed() + patch_single_stream_diff()
-static hpatch_force_inline
-hpatch_BOOL patch_single_compressed_diff(const hpatch_TStreamOutput* out_newData,          //sequential write
-                                         const hpatch_TStreamInput*  oldData,              //random read
-                                         const hpatch_TStreamInput*  singleCompressedDiff, //sequential read
-                                         hpatch_StreamPos_t          diffData_pos, //diffData begin pos in singleCompressedDiff
-                                         hpatch_StreamPos_t          uncompressedSize,
-                                         hpatch_StreamPos_t          compressedSize,
-                                         hpatch_TDecompress*         decompressPlugin,
+    
+//patch single diffStream
+ 
+	//patch with singleCompressedDiff by a listener
+	//	used (stepMemSize memory) + (I/O cache memory) + (decompress memory*1)
+    //  every byte in singleCompressedDiff will only be read once in order
+	//  singleCompressedDiff create by create_single_compressed_diff()
+    //  you can download&patch diffData at the same time, without saving it to disk
+	//  same as call getSingleCompressedDiffInfo() + listener->onDiffInfo() + patch_single_compressed_diff()
+    hpatch_BOOL patch_single_stream_by(sspatch_listener_t* listener, //call back when got diffInfo
+                                       const hpatch_TStreamOutput* out_newData,          //sequential write
+                                       const hpatch_TStreamInput*  oldData,              //random read
+                                       const hpatch_TStreamInput*  singleCompressedDiff, //sequential read every byte
+                                       hpatch_StreamPos_t  diffInfo_pos //default 0, begin pos in singleCompressedDiff
+                                       );
+    static hpatch_inline hpatch_BOOL 
+        patch_single_stream_by_mem(sspatch_listener_t* listener,
+                                   unsigned char* out_newData,unsigned char* out_newData_end,
+                                   const unsigned char* oldData,const unsigned char* oldData_end,
+                                   const unsigned char* diff,const unsigned char* diff_end){
+            hpatch_TStreamOutput out_newStream;
+            hpatch_TStreamInput  oldStream;
+            hpatch_TStreamInput  diffStream;
+            mem_as_hStreamOutput(&out_newStream,out_newData,out_newData_end);
+            mem_as_hStreamInput(&oldStream,oldData,oldData_end);
+            mem_as_hStreamInput(&diffStream,diff,diff_end);
+            return patch_single_stream_by(listener,&out_newStream,&oldStream,&diffStream,0);
+        }
+    
+    hpatch_BOOL getSingleCompressedDiffInfo(hpatch_singleCompressedDiffInfo* out_diffInfo,
+                                            const hpatch_TStreamInput*  singleCompressedDiff,   //sequential read
+                                            hpatch_StreamPos_t diffInfo_pos/*default 0, begin pos in singleCompressedDiff*/);
+
+    hpatch_inline static hpatch_BOOL
+        getSingleCompressedDiffInfo_mem(hpatch_singleCompressedDiffInfo* out_diffInfo,
+                                        const unsigned char* singleCompressedDiff,
+                                        const unsigned char* singleCompressedDiff_end){
+            hpatch_TStreamInput  diffStream;
+            mem_as_hStreamInput(&diffStream,singleCompressedDiff,singleCompressedDiff_end);
+            return getSingleCompressedDiffInfo(out_diffInfo,&diffStream,0);            
+        }
+    
+   
+	//patch with singleCompressedDiff
+	//	used (stepMemSize memory) + (I/O cache memory) + (decompress memory*1)
+	//	note: (I/O cache memory) >= hpatch_kStreamCacheSize*3
+	//  temp_cache_end-temp_cache == stepMemSize + (I/O cache memory)
+	//  singleCompressedDiff create by create_single_compressed_diff()
+	//  decompressPlugin can null when no compressed data in singleCompressedDiff
+	//  same as call compressed_stream_as_uncompressed() + patch_single_stream_diff()
+    hpatch_BOOL patch_single_compressed_diff(const hpatch_TStreamOutput* out_newData,          //sequential write
+                                             const hpatch_TStreamInput*  oldData,              //random read
+                                             const hpatch_TStreamInput*  singleCompressedDiff, //sequential read
+                                             hpatch_StreamPos_t          diffData_pos, //begin pos in singleCompressedDiff
+                                             hpatch_StreamPos_t          uncompressedSize,
+                                             hpatch_TDecompress*         decompressPlugin,
+                                             hpatch_StreamPos_t coverCount,hpatch_size_t stepMemSize,
+                                             unsigned char* temp_cache,unsigned char* temp_cache_end);
+    
+    hpatch_BOOL compressed_stream_as_uncompressed(hpatch_TUncompresser_t* uncompressedStream,hpatch_StreamPos_t uncompressedSize,
+                                                  hpatch_TDecompress* decompressPlugin,const hpatch_TStreamInput* compressedStream,
+                                                  hpatch_StreamPos_t compressed_pos,hpatch_StreamPos_t compressed_end);
+    void close_compressed_stream_as_uncompressed(hpatch_TUncompresser_t* uncompressedStream);
+
+    hpatch_BOOL patch_single_stream_diff(const hpatch_TStreamOutput*  out_newData,          //sequential write
+                                         const hpatch_TStreamInput*   oldData,              //random read
+                                         const hpatch_TStreamInput*   uncompressedDiffData, //sequential read
+                                         hpatch_StreamPos_t           diffData_pos, //begin pos in uncompressedDiffData
                                          hpatch_StreamPos_t coverCount,hpatch_size_t stepMemSize,
-                                         unsigned char* temp_cache,unsigned char* temp_cache_end,
-                                         sspatch_coversListener_t* coversListener, //default NULL, call by on got covers
-                                         size_t threadNum){ // 1..5; if >1, multi-thread for I/O & decompress etc.
-        return _patch_single_compressed_diff_mt(out_newData,oldData,singleCompressedDiff,diffData_pos,uncompressedSize,compressedSize,
-                                                decompressPlugin,coverCount,stepMemSize,temp_cache,temp_cache_end,coversListener,
-                                                threadNum,hpatchMTSets_full);
-    }
+                                         unsigned char* temp_cache,unsigned char* temp_cache_end);
 
-hpatch_BOOL compressed_stream_as_uncompressed(hpatch_TUncompresser_t* uncompressedStream,hpatch_StreamPos_t uncompressedSize,
-                                                hpatch_TDecompress* decompressPlugin,const hpatch_TStreamInput* compressedStream,
-                                                hpatch_StreamPos_t compressed_pos,hpatch_StreamPos_t compressed_end);
-void close_compressed_stream_as_uncompressed(hpatch_TUncompresser_t* uncompressedStream);
-
-hpatch_BOOL patch_single_stream_diff(const hpatch_TStreamOutput*  out_newData,          //sequential write
-                                     const hpatch_TStreamInput*   oldData,              //random read
-                                     const hpatch_TStreamInput*   uncompressedDiffData, //sequential read
-                                     hpatch_StreamPos_t           diffData_pos,//diffData begin pos in uncompressedDiffData
-                                     hpatch_StreamPos_t           diffData_posEnd,//diffData end pos in uncompressedDiffData
-                                     hpatch_StreamPos_t coverCount,hpatch_size_t stepMemSize,
-                                     unsigned char* temp_cache,unsigned char* temp_cache_end,
-                                     sspatch_coversListener_t* coversListener,
-                                     hpatch_BOOL isNeedOutCache //default true: each time accumulating some data be write to out_newData;
-                                    );
 
 #ifdef __cplusplus
 }

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HPatch/patch_private.h

@@ -29,7 +29,7 @@
 #ifndef HPatch_patch_private_h
 #define HPatch_patch_private_h
 
-#include "patch.h"
+#include "patch_types.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -82,7 +82,6 @@ hpatch_inline static
 void _TStreamCacheClip_init(TStreamCacheClip* sclip,const hpatch_TStreamInput* srcStream,
                             hpatch_StreamPos_t streamPos,hpatch_StreamPos_t streamPos_end,
                             unsigned char* aCache,hpatch_size_t cacheSize){
-    assert((streamPos<=streamPos_end)&&(streamPos_end<=(srcStream?srcStream->streamSize:0)));
     sclip->streamPos=streamPos;
     sclip->streamPos_end=streamPos_end;
     sclip->srcStream=srcStream;
@@ -91,10 +90,10 @@ void _TStreamCacheClip_init(TStreamCacheClip* sclip,const hpatch_TStreamInput* s
     sclip->cacheEnd=cacheSize;
 }
     
-#define _TStreamCacheClip_isFinish(sclip)     ( 0==_TStreamCacheClip_leaveSize(sclip) )
+#define _TStreamCacheClip_isFinish(sclip)     ( 0==_TStreamCacheClip_streamSize(sclip) )
 #define _TStreamCacheClip_isCacheEmpty(sclip) ( (sclip)->cacheBegin==(sclip)->cacheEnd )
 #define _TStreamCacheClip_cachedSize(sclip)   ( (hpatch_size_t)((sclip)->cacheEnd-(sclip)->cacheBegin) )
-#define _TStreamCacheClip_leaveSize(sclip)   \
+#define _TStreamCacheClip_streamSize(sclip)   \
             (  (hpatch_StreamPos_t)((sclip)->streamPos_end-(sclip)->streamPos)  \
                 + (hpatch_StreamPos_t)_TStreamCacheClip_cachedSize(sclip)  )
 #define _TStreamCacheClip_readPosOfSrcStream(sclip) ( \
@@ -124,61 +123,15 @@ unsigned char* _TStreamCacheClip_readData(TStreamCacheClip* sclip,hpatch_size_t
 
 hpatch_BOOL _TStreamCacheClip_readDataTo(TStreamCacheClip* sclip,
                                          unsigned char* out_buf,unsigned char* bufEnd);
-hpatch_BOOL _TStreamCacheClip_addDataTo(TStreamCacheClip* self,unsigned char* dst,hpatch_size_t addLen);
 
 hpatch_BOOL _TStreamCacheClip_unpackUIntWithTag(TStreamCacheClip* sclip,
                                                 hpatch_StreamPos_t* result,const hpatch_uint kTagBit);
+hpatch_BOOL _TStreamCacheClip_readUInt(TStreamCacheClip* sclip,hpatch_StreamPos_t* result,hpatch_size_t uintSize);
 
-hpatch_BOOL _TStreamCacheClip_readStr_end(TStreamCacheClip* sclip,hpatch_byte endTag,
-                                          char* out_str,size_t strBufLen);
-hpatch_inline static
-hpatch_BOOL _TStreamCacheClip_readType_end(TStreamCacheClip* sclip,hpatch_byte endTag,
-                                           char out_type[hpatch_kMaxPluginTypeLength+1]){
-                return _TStreamCacheClip_readStr_end(sclip,endTag,out_type,hpatch_kMaxPluginTypeLength+1); }
-
-// Stream Clip cache
-typedef struct {
-    hpatch_StreamPos_t           writeToPos;
-    const hpatch_TStreamOutput*  dstStream;
-    unsigned char*  cacheBuf;
-    hpatch_size_t   cacheCur;
-    hpatch_size_t   cacheEnd;
-} _TOutStreamCache;
-
-static hpatch_inline void _TOutStreamCache_init(_TOutStreamCache* self,const hpatch_TStreamOutput*  dstStream,
-                                                unsigned char* aCache,hpatch_size_t aCacheSize){
-    self->writeToPos=0;
-    self->cacheCur=0;
-    self->dstStream=dstStream;
-    self->cacheBuf=aCache;
-    self->cacheEnd=aCacheSize;
-}
-hpatch_inline static
-void _TOutStreamCache_resetCache(_TOutStreamCache* self,unsigned char* aCache,hpatch_size_t aCacheSize){
-    assert(0==self->cacheCur);
-    self->cacheBuf=aCache;
-    self->cacheEnd=aCacheSize;
-}
-
-static hpatch_inline hpatch_StreamPos_t _TOutStreamCache_leaveSize(const _TOutStreamCache* self){
-    return self->dstStream->streamSize-self->writeToPos;
-}
-static hpatch_inline hpatch_BOOL _TOutStreamCache_isFinish(const _TOutStreamCache* self){
-    return self->writeToPos==self->dstStream->streamSize;
-}
-static hpatch_inline hpatch_size_t _TOutStreamCache_cachedDataSize(const _TOutStreamCache* self){
-    return self->cacheCur;
-}
-hpatch_BOOL _TOutStreamCache_flush(_TOutStreamCache* self);
-hpatch_BOOL _TOutStreamCache_write(_TOutStreamCache* self,const unsigned char* data,hpatch_size_t dataSize);
-hpatch_BOOL _TOutStreamCache_fill(_TOutStreamCache* self,hpatch_byte fillValue,hpatch_StreamPos_t fillLength);
-
-hpatch_BOOL _TOutStreamCache_copyFromClip(_TOutStreamCache* self,TStreamCacheClip* src,hpatch_StreamPos_t copyLength);
-hpatch_BOOL _TOutStreamCache_copyFromStream(_TOutStreamCache* self,const hpatch_TStreamInput* src,
-                                            hpatch_StreamPos_t srcPos,hpatch_StreamPos_t copyLength);
-hpatch_BOOL _TOutStreamCache_copyFromSelf(_TOutStreamCache* self,hpatch_StreamPos_t aheadLength,hpatch_StreamPos_t copyLength);
-
+hpatch_BOOL _TStreamCacheClip_readType_end(TStreamCacheClip* sclip,unsigned char endTag,
+                                           char out_type[hpatch_kMaxPluginTypeLength+1]);
 
+        
     typedef struct _TDecompressInputStream{
         hpatch_TStreamInput         IInputStream;
         hpatch_TDecompress*         decompressPlugin;
@@ -205,39 +158,6 @@ void TDiffToSingleStream_init(TDiffToSingleStream* self,const hpatch_TStreamInpu
 hpatch_inline static 
 void TDiffToSingleStream_setInSingleStream(TDiffToSingleStream* self,hpatch_StreamPos_t singleStreamPos){
     self->isInSingleStream=hpatch_TRUE; }
-    
-hpatch_inline static
-void TDiffToSingleStream_resetStream(TDiffToSingleStream* self,const hpatch_TStreamInput* diffStream){
-    self->diffStream=diffStream; }
-
-static hpatch_force_inline 
-hpatch_StreamPos_t _patch_cache_all_old_needSize(hpatch_StreamPos_t oldDataSize,hpatch_size_t kMinTempCacheSize){
-                                                    return oldDataSize+kMinTempCacheSize+sizeof(hpatch_TStreamInput)+sizeof(hpatch_StreamPos_t); }
-#if (_IS_NEED_CACHE_OLD_ALL)
-static hpatch_force_inline 
-hpatch_BOOL _patch_is_can_cache_all_old(hpatch_StreamPos_t oldDataSize,hpatch_size_t kMinTempCacheSize,hpatch_size_t tempCacheSize){
-                                            return tempCacheSize>=_patch_cache_all_old_needSize(oldDataSize,kMinTempCacheSize); }
-hpatch_BOOL _patch_cache_all_old(const hpatch_TStreamInput** poldData,size_t kMinTempCacheSize,
-                                 hpatch_byte** ptemp_cache,hpatch_byte** ptemp_cache_end,hpatch_BOOL* out_isReadError);// try cache all oldData
-#else
-static hpatch_force_inline 
-hpatch_BOOL _patch_is_can_cache_all_old(hpatch_StreamPos_t oldDataSize,hpatch_size_t kMinTempCacheSize,hpatch_size_t tempCacheSize){
-                                            return hpatch_FALSE; }
-static hpatch_force_inline 
-hpatch_BOOL _patch_cache_all_old(const hpatch_TStreamInput** poldData,size_t kMinTempCacheSize,
-                                 hpatch_byte** ptemp_cache,hpatch_byte** ptemp_cache_end,hpatch_BOOL* out_isReadError){
-                                            *out_isReadError=hpatch_FALSE; return hpatch_FALSE; }
-#endif
-
-#if (_IS_NEED_CACHE_OLD_BY_COVERS)
-
-hpatch_size_t _patch_step_cache_old_canUsedSize(hpatch_size_t stepCoversMemSize,hpatch_size_t kMinTempCacheSize,hpatch_size_t tempCacheSize);
-
-// try cache part of oldData, used by patch_single_stream_diff()
-hpatch_BOOL _patch_step_cache_old(const hpatch_TStreamInput** poldData,hpatch_StreamPos_t newDataSize,size_t stepCoversMemSize,
-                                  size_t kMinTempCacheSize,hpatch_byte** ptemp_cache,hpatch_byte** ptemp_cache_end);
-hpatch_BOOL _patch_step_cache_old_onStepCovers(const hpatch_TStreamInput* self,const unsigned char* covers_cache,const unsigned char* covers_cacheEnd);
-#endif // _IS_NEED_CACHE_OLD_BY_COVERS
 
 #ifdef __cplusplus
 }

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HPatch/patch_types.h

@@ -36,22 +36,14 @@
 extern "C" {
 #endif
 
-#define HDIFFPATCH_VERSION_MAJOR    4
-#define HDIFFPATCH_VERSION_MINOR    12
-#define HDIFFPATCH_VERSION_RELEASE  0
+#define HDIFFPATCH_VERSION_MAJOR    3
+#define HDIFFPATCH_VERSION_MINOR    1
+#define HDIFFPATCH_VERSION_RELEASE  1
 
 #define _HDIFFPATCH_VERSION          HDIFFPATCH_VERSION_MAJOR.HDIFFPATCH_VERSION_MINOR.HDIFFPATCH_VERSION_RELEASE
 #define _HDIFFPATCH_QUOTE(str) #str
 #define _HDIFFPATCH_EXPAND_AND_QUOTE(str) _HDIFFPATCH_QUOTE(str)
 #define HDIFFPATCH_VERSION_STRING   _HDIFFPATCH_EXPAND_AND_QUOTE(_HDIFFPATCH_VERSION)
-#define HDIFFPATCH_VERSION_NUMBER   ((HDIFFPATCH_VERSION_MAJOR*1000+HDIFFPATCH_VERSION_MINOR)*1000+HDIFFPATCH_VERSION_RELEASE)
-
-#ifndef _IS_USED_MULTITHREAD
-#   define _IS_USED_MULTITHREAD 1
-#endif
-#ifndef _HPATCH_IS_USED_MULTITHREAD
-#   define _HPATCH_IS_USED_MULTITHREAD   _IS_USED_MULTITHREAD
-#endif
 
 #ifndef hpatch_int
     typedef int                 hpatch_int;
@@ -83,42 +75,19 @@ extern "C" {
 #ifndef hpatch_StreamPos_t
     typedef hpatch_uint64_t     hpatch_StreamPos_t; // file size type
 #endif
-#define hpatch_kNullStreamPos   (~(hpatch_StreamPos_t)0)
 
 #ifndef hpatch_BOOL
-    typedef unsigned int        hpatch_BOOL;
+    typedef int                 hpatch_BOOL;
 #endif
 #define     hpatch_FALSE    0
 #define     hpatch_TRUE     ((hpatch_BOOL)(!hpatch_FALSE))
     
-#ifndef hpatch_byte
-    typedef unsigned char       hpatch_byte;
-#endif
-
-#if (_HPATCH_IS_USED_errno)
-typedef    unsigned int hpatch_FileError_t;// 0: no error; other: saved errno value;
-#else
-typedef    hpatch_BOOL  hpatch_FileError_t;// 0: no error; other: error;
-#endif
-
 #ifdef _MSC_VER
 #   define hpatch_inline _inline
 #else
 #   define hpatch_inline inline
 #endif
 
-#ifndef hpatch_force_inline
-#if defined(_MSC_VER)
-#   define hpatch_force_inline __forceinline
-#elif defined(__GNUC__) || defined(__clang__) || defined(__CC_ARM)
-#   define hpatch_force_inline __attribute__((always_inline)) inline
-#elif defined(__ICCARM__)
-#   define hpatch_force_inline _Pragma("inline=forced")
-#else
-#   define hpatch_force_inline hpatch_inline
-#endif
-#endif
-
 //PRIu64 for printf type hpatch_StreamPos_t
 #ifndef PRIu64
 #   ifdef _MSC_VER
@@ -127,24 +96,6 @@ typedef    hpatch_BOOL  hpatch_FileError_t;// 0: no error; other: error;
 #       define PRIu64 "llu"
 #   endif
 #endif
-
-#ifdef ANDROID
-#   include <android/log.h>
-#   define LOG_ERR(...) __android_log_print(ANDROID_LOG_ERROR, "hpatch", __VA_ARGS__)
-#else
-#   include <stdio.h>  //for stderr
-#   define LOG_ERR(...) fprintf(stderr,__VA_ARGS__)
-#endif
-#ifndef _HPATCH_IS_USED_errno
-#   define  _HPATCH_IS_USED_errno 1
-#endif
-#define _hpatch_import_system_tag "call import system api"
-#if (_HPATCH_IS_USED_errno)
-#   define  LOG_ERRNO(_err_no) \
-        LOG_ERR(_hpatch_import_system_tag" error! errno: %d, errmsg: %s.\n",_err_no,strerror(_err_no))
-#else
-#   define  LOG_ERRNO(_err_no) LOG_ERR(_hpatch_import_system_tag" error!\n")
-#endif
     
 #define _hpatch_align_type_lower(uint_type,p,align2pow) (((uint_type)(p)) & (~(uint_type)((align2pow)-1)))
 #define _hpatch_align_lower(p,align2pow) _hpatch_align_type_lower(hpatch_size_t,p,align2pow)
@@ -193,13 +144,6 @@ typedef    hpatch_BOOL  hpatch_FileError_t;// 0: no error; other: error;
     } hpatch_compressedDiffInfo;
     
     typedef void*  hpatch_decompressHandle;
-    typedef enum{
-        hpatch_dec_ok=0,
-        hpatch_dec_mem_error,
-        hpatch_dec_open_error,
-        hpatch_dec_error,
-        hpatch_dec_close_error,
-    } hpatch_dec_error_t;
     typedef struct hpatch_TDecompress{
         hpatch_BOOL        (*is_can_open)(const char* compresseType);
         //error return 0.
@@ -213,23 +157,14 @@ typedef    hpatch_BOOL  hpatch_FileError_t;// 0: no error; other: error;
         //decompress_part() must out (out_part_data_end-out_part_data), otherwise error return hpatch_FALSE
         hpatch_BOOL    (*decompress_part)(hpatch_decompressHandle decompressHandle,
                                           unsigned char* out_part_data,unsigned char* out_part_data_end);
-        //reset_code add new compressed data; for support vcpatch, can NULL
-        hpatch_BOOL         (*reset_code)(hpatch_decompressHandle decompressHandle,
-                                          hpatch_StreamPos_t dataSize,
-                                          const struct hpatch_TStreamInput* codeStream,
-                                          hpatch_StreamPos_t code_begin,
-                                          hpatch_StreamPos_t code_end);
-        volatile hpatch_dec_error_t decError; //if you used decError value, once patch must used it's own hpatch_TDecompress
     } hpatch_TDecompress;
-    #define _hpatch_update_decError(decompressPlugin,errorCode) \
-        do { if ((decompressPlugin)->decError==hpatch_dec_ok)   \
-                (decompressPlugin)->decError=errorCode;     } while(0)
+
     
     
-    const hpatch_TStreamInput* mem_as_hStreamInput(hpatch_TStreamInput* out_stream,
-                                                   const unsigned char* mem,const unsigned char* mem_end);
-    const hpatch_TStreamOutput* mem_as_hStreamOutput(hpatch_TStreamOutput* out_stream,
-                                                     unsigned char* mem,unsigned char* mem_end);
+    void mem_as_hStreamInput(hpatch_TStreamInput* out_stream,
+                             const unsigned char* mem,const unsigned char* mem_end);
+    void mem_as_hStreamOutput(hpatch_TStreamOutput* out_stream,
+                              unsigned char* mem,unsigned char* mem_end);
     
     hpatch_BOOL hpatch_deccompress_mem(hpatch_TDecompress* decompressPlugin,
                                        const unsigned char* code,const unsigned char* code_end,
@@ -272,18 +207,7 @@ typedef    hpatch_BOOL  hpatch_FileError_t;// 0: no error; other: error;
         hpatch_StreamPos_t newPos;
         hpatch_StreamPos_t length;
     } hpatch_TCover;
-    typedef struct hpatch_TCover32{
-        hpatch_uint32_t oldPos;
-        hpatch_uint32_t newPos;
-        hpatch_uint32_t length;
-    } hpatch_TCover32;
-    typedef struct hpatch_TCover_sz{
-        size_t oldPos;
-        size_t newPos;
-        size_t length;
-    } hpatch_TCover_sz;
 
-    //opened input covers
     typedef struct hpatch_TCovers{
         hpatch_StreamPos_t (*leave_cover_count)(const struct hpatch_TCovers* covers);
         //read out a cover,and to next cover pos; if error then return false
@@ -292,11 +216,6 @@ typedef    hpatch_BOOL  hpatch_FileError_t;// 0: no error; other: error;
         hpatch_BOOL                    (*close)(struct hpatch_TCovers* covers);
     } hpatch_TCovers;
     
-    //output covers
-    typedef struct hpatch_TOutputCovers{
-        hpatch_BOOL (*push_cover)(struct hpatch_TOutputCovers* out_covers,const hpatch_TCover* cover); 
-        void (*collate_covers)(struct hpatch_TOutputCovers* out_covers); // for support search covers by multi-thread
-    } hpatch_TOutputCovers;
     
     typedef struct{
         hpatch_StreamPos_t  newDataSize;
@@ -308,13 +227,6 @@ typedef    hpatch_BOOL  hpatch_FileError_t;// 0: no error; other: error;
         hpatch_StreamPos_t  stepMemSize;
         char                compressType[hpatch_kMaxPluginTypeLength+1]; //ascii cstring
     } hpatch_singleCompressedDiffInfo;
-
-    hpatch_inline static void _singleDiffInfoToHDiffInfo(hpatch_compressedDiffInfo* out_diffInfo,const hpatch_singleCompressedDiffInfo* singleDiffInfo){
-        out_diffInfo->newDataSize=singleDiffInfo->newDataSize;
-        out_diffInfo->oldDataSize=singleDiffInfo->oldDataSize;
-        out_diffInfo->compressedCount=(singleDiffInfo->compressedSize>0)?1:0;
-        memcpy(out_diffInfo->compressType,singleDiffInfo->compressType,strlen(singleDiffInfo->compressType)+1);
-    }
     
     typedef struct sspatch_listener_t{ 
         void*         import;   
@@ -332,28 +244,6 @@ typedef    hpatch_BOOL  hpatch_FileError_t;// 0: no error; other: error;
         hpatch_TDecompress*     _decompressPlugin;
         hpatch_decompressHandle _decompressHandle;
     } hpatch_TUncompresser_t;
-
-    typedef struct sspatch_coversListener_t{
-        void*         import;
-        void        (*onStepCoversReset)(struct sspatch_coversListener_t* listener,hpatch_StreamPos_t leaveCoverCount);//can NULL, data(in covers_cache) will invalid; if leaveCoverCount==0, step finish 
-        void        (*onStepCovers)(struct sspatch_coversListener_t* listener,
-                                    const unsigned char* covers_cache,const unsigned char* covers_cacheEnd);//if covers_cache==covers_cacheEnd==0, step finish
-    } sspatch_coversListener_t;
-    
-    typedef struct{
-        const unsigned char* covers_cache;
-        const unsigned char* covers_cacheEnd;
-        hpatch_StreamPos_t   lastOldEnd;
-        hpatch_StreamPos_t   lastNewEnd;
-        hpatch_TCover        cover;
-    } sspatch_covers_t;
-
-    hpatch_inline static void sspatch_covers_init(sspatch_covers_t* self) { memset(self,0,sizeof(*self)); }
-    hpatch_inline static void sspatch_covers_setCoversCache(sspatch_covers_t* self,const unsigned char* covers_cache,const unsigned char* covers_cacheEnd){
-                                    self->covers_cache=covers_cache; self->covers_cacheEnd=covers_cacheEnd; }
-    hpatch_inline static hpatch_BOOL sspatch_covers_isHaveNextCover(const sspatch_covers_t* self) { return (self->covers_cache!=(self)->covers_cacheEnd); }
-
-    hpatch_BOOL sspatch_covers_nextCover(sspatch_covers_t* self);
     
 #ifdef __cplusplus
 }