react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/limit_mem_diff/stream_serialize.h

@@ -30,11 +30,25 @@
 #include "covers.h"
 #include "../pack_uint.h" //for packUInt_fixSize
 #include "../mem_buf.h"
-#include "../bytes_rle.h"
-
 struct hdiff_TCompress;
 namespace hdiff_private{
 
+struct TCompressedStream:public hpatch_TStreamOutput{
+    TCompressedStream(const hpatch_TStreamOutput*  _out_code,
+                      hpatch_StreamPos_t _writePos,hpatch_StreamPos_t _kLimitOutCodeSize,
+                      const hpatch_TStreamInput*   _in_stream);
+    inline bool  is_overLimit()const { return _is_overLimit; }
+private:
+    const hpatch_TStreamOutput*  out_code;
+    hpatch_StreamPos_t           out_pos;
+    hpatch_StreamPos_t           out_posLimitEnd;
+    const hpatch_TStreamInput*   in_stream;
+    hpatch_StreamPos_t           _writeToPos_back;
+    bool                         _is_overLimit;
+    static hpatch_BOOL _write_code(const hpatch_TStreamOutput* stream,hpatch_StreamPos_t writeToPos,
+                                   const unsigned char* data,const unsigned char* data_end);
+};
+
 struct TCoversStream:public hpatch_TStreamInput{
     TCoversStream(const TCovers& _covers,hpatch_StreamPos_t cover_buf_size);
     ~TCoversStream();
@@ -48,59 +62,17 @@ private:
     hpatch_StreamPos_t          lastOldEnd;
     hpatch_StreamPos_t          lastNewEnd;
     hpatch_StreamPos_t          _readFromPos_back;
-    enum { kCodeBufSize = hdiff_kFileIOBufBestSize };
+    enum { kCodeBufSize = hpatch_kFileIOBufBetterSize };
     
     static hpatch_BOOL _read(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
                              unsigned char* out_data,unsigned char* out_data_end);
 };
 
-
-struct TNewDataSubDiffStream:public hpatch_TStreamInput{
-    TNewDataSubDiffStream(const hdiff_TStreamInput* _newData,const hdiff_TStreamInput* _oldData,
-                          const TCovers& _covers,bool _isOnlySubCover=false,bool _isZeroSubDiff=false);
-    inline ~TNewDataSubDiffStream(){ assert(curReadPos==streamSize); }
-private:
-    hpatch_StreamPos_t curReadNewPos;
-    hpatch_StreamPos_t curReadOldPos;
-    hpatch_StreamPos_t curReadPos;
-    hpatch_StreamPos_t curDataLen;
-    size_t nextCoveri;
-    const hdiff_TStreamInput* newData;
-    const hdiff_TStreamInput* oldData;
-    const TCovers& covers;
-    const bool isOnlySubCover;
-    const bool isZeroSubDiff;
-    TAutoMem _cache;
-    void initRead();
-    void readTo(unsigned char* out_data,unsigned char* out_data_end);
-    static hpatch_BOOL _read(const struct hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
-                             unsigned char* out_data,unsigned char* out_data_end);
-};
-
-struct TNewDataSubDiffStream_mem:public TNewDataSubDiffStream{
-    TNewDataSubDiffStream_mem(const unsigned char* newData,const unsigned char* newData_end,
-                              const unsigned char* oldData,const unsigned char* oldData_end,
-                              const TCovers& _covers,bool _isOnlySubCover=false,bool _isZeroSubDiff=false);
-private:
-    hdiff_TStreamInput mem_newData;
-    hdiff_TStreamInput mem_oldData;
-};
-
 struct TNewDataDiffStream:public hpatch_TStreamInput{
-    inline TNewDataDiffStream(const TCovers& _covers,const hpatch_TStreamInput* _newData,
-                              hpatch_StreamPos_t newDataDiff_size)
-            :covers(_covers),newData(_newData) { _init(newDataDiff_size); }
-    inline TNewDataDiffStream(const TCovers& _covers,const hpatch_TStreamInput* _newData)
-        :covers(_covers),newData(_newData) { _init(getDataSize(_covers,_newData->streamSize)); }
-    inline TNewDataDiffStream(const TCovers& _covers,const hpatch_TStreamInput* _newData,
-                              size_t coveri,hpatch_StreamPos_t newDataPos,hpatch_StreamPos_t newDataPosEnd)
-        :covers(_covers),newData(_newData){ _initByRange(coveri,newDataPos,newDataPosEnd); }
+    TNewDataDiffStream(const TCovers& _covers,const hpatch_TStreamInput* _newData,
+                       hpatch_StreamPos_t newDataDiff_size);
     static hpatch_StreamPos_t getDataSize(const TCovers& covers,hpatch_StreamPos_t newDataSize);
 private:
-    static hpatch_StreamPos_t getDataSizeByRange(const TCovers& covers,size_t coveri,
-                                                 hpatch_StreamPos_t newDataPos,hpatch_StreamPos_t newDataPosEnd);
-    void _init(hpatch_StreamPos_t newDataDiff_size);
-    void _initByRange(size_t coveri,hpatch_StreamPos_t newDataPos,hpatch_StreamPos_t newDataPosEnd);
     const TCovers&              covers;
     const hpatch_TStreamInput*  newData;
     hpatch_StreamPos_t          curNewPos;
@@ -108,117 +80,16 @@ private:
     hpatch_StreamPos_t          lastNewEnd;
     size_t                      readedCoverCount;
     hpatch_StreamPos_t          _readFromPos_back;
-
-    //by range
-    size_t                      _coveri;
-    hpatch_StreamPos_t          _newDataPos;
-
     static hpatch_BOOL _read(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
                              unsigned char* out_data,unsigned char* out_data_end);
 };
 
-struct TNewDataSubDiffCoverStream:public hpatch_TStreamInput{
-    TNewDataSubDiffCoverStream(const hpatch_TStreamInput* _newStream,
-                               const hpatch_TStreamInput* _oldStream,bool _isZeroSubDiff);
-    void resetCover(const TCover& _cover);
-    void resetCoverLen(hpatch_StreamPos_t coverLen);
-    const bool isZeroSubDiff;
-private:
-    hpatch_StreamPos_t inStreamLen;
-    size_t curDataLen;
-    const hpatch_TStreamInput* newStream;
-    const hpatch_TStreamInput* oldStream;
-    TCover cover;
-    unsigned char* newData;
-    unsigned char* oldData;
-    TAutoMem _cache;
-    void initRead();
-    hpatch_BOOL _updateCache(hpatch_StreamPos_t readFromPos);
-    hpatch_BOOL readTo(hpatch_StreamPos_t readFromPos,unsigned char* out_data,unsigned char* out_data_end);
-    static hpatch_BOOL _read(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
-                             unsigned char* out_data,unsigned char* out_data_end);
-};
-
-class TStreamClip:public hpatch_TStreamInput{
-public:
-    inline explicit TStreamClip():_decompressHandle(0){ clear(); }
-    inline TStreamClip(const hpatch_TStreamInput* stream,
-                         hpatch_StreamPos_t clipBeginPos,hpatch_StreamPos_t clipEndPos,
-                         hpatch_TDecompress* decompressPlugin=0,hpatch_StreamPos_t uncompressSize=0)
-                         :_decompressHandle(0){ reset(stream,clipBeginPos,clipEndPos,decompressPlugin,uncompressSize); }
-    void reset(const hpatch_TStreamInput* stream,
-               hpatch_StreamPos_t clipBeginPos,hpatch_StreamPos_t clipEndPos,
-               hpatch_TDecompress* decompressPlugin=0,hpatch_StreamPos_t uncompressSize=0);
-    inline ~TStreamClip() { clear(); }
-    inline void clear() { closeDecompressHandle(); streamSize=0; }
-private:
-    const hpatch_TStreamInput*  _src;
-    hpatch_StreamPos_t          _src_begin;
-    hpatch_StreamPos_t          _src_end;
-    hpatch_TDecompress*         _decompressPlugin;
-    hpatch_decompressHandle     _decompressHandle;
-    hpatch_StreamPos_t          _read_uncompress_pos;
-    void closeDecompressHandle();
-    void openDecompressHandle();
-    static hpatch_BOOL _clip_read(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
-                                  unsigned char* out_data,unsigned char* out_data_end);
-};
-
-struct TStepStream:public hpatch_TStreamInput{
-    TStepStream(const hpatch_TStreamInput* newStream,const hpatch_TStreamInput* oldStream,
-                bool isZeroSubDiff,const TCovers& covers,size_t patchStepMemSize);
-    inline size_t getCoverCount()const{ return endCoverCount; }
-    inline size_t getMaxStepMemSize()const{ return endMaxStepMemSize; }
-private:
-    TNewDataSubDiffCoverStream  subDiff;
-    TNewDataDiffStream          newDataDiff;
-    const TCovers&  covers;
-    const size_t    patchStepMemSize;
-    const hpatch_StreamPos_t newDataSize;
-    size_t  curCoverCount;
-    size_t  endCoverCount;
-    size_t  curMaxStepMemSize;
-    size_t  endMaxStepMemSize;
-    hpatch_StreamPos_t lastOldEnd;
-    hpatch_StreamPos_t lastNewEnd;
-    std::vector<unsigned char> step_bufCover;
-    TSingleStreamRLE0  step_bufRle;
-    hpatch_StreamPos_t step_dataDiffSize;
-    hpatch_StreamPos_t newDataDiffReadPos;
-    bool    isHaveLastCover;
-    bool    isHaveLeftCover;
-    bool    isHaveRightCover;
-    TCover  lastCover;
-    TCover  leftCover;
-    TCover  rightCover;
-    size_t  cur_i;
-    TCover  cover;
-    const TCover* pCurCover;
-    bool    isInInit;
-    hpatch_StreamPos_t  sumBufSize_forInit;
-    size_t              step_bufCover_size;
-    std::vector<unsigned char> step_buf;
-    TStreamClip                step_dataDiff;
-    hpatch_StreamPos_t readFromPosBack;
-    hpatch_StreamPos_t         readBufPos;
-    void initStream();
-    void beginStep();
-    bool doStep();
-    void _last_flush_step();
-    void _flush_step_code();
-    hpatch_BOOL readTo(unsigned char* out_data,unsigned char* out_data_end);
-    static hpatch_BOOL _read(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
-                             unsigned char* out_data,unsigned char* out_data_end);
-};
-
-
 struct TDiffStream{
-    explicit TDiffStream(const hpatch_TStreamOutput* _out_diff,
-                         hpatch_StreamPos_t out_diff_curPos=0);
+    explicit TDiffStream(const hpatch_TStreamOutput* _out_diff);
     ~TDiffStream();
     
     void pushBack(const unsigned char* src,size_t n);
-    size_t packUInt(hpatch_StreamPos_t uValue);
+    void packUInt(hpatch_StreamPos_t uValue);
     inline TPlaceholder packUInt_pos(hpatch_StreamPos_t uValue){
         hpatch_StreamPos_t pos=writePos;
         packUInt(uValue);
@@ -226,29 +97,16 @@ struct TDiffStream{
     }
     void packUInt_update(const TPlaceholder& pos,hpatch_StreamPos_t uValue);
     
-    hpatch_StreamPos_t pushStream(const hpatch_TStreamInput* stream,
-                                  const hdiff_TCompress*     compressPlugin,
-                                  const TPlaceholder&        update_compress_sizePos,
-                                  bool isMustCompress=false,const hpatch_StreamPos_t cancelSizeOnCancelCompress=0);
-    hpatch_StreamPos_t pushStream(const hpatch_TStreamInput* stream,
-                                  const hdiff_TCompress*     compressPlugin,
-                                  bool isMustCompress=false,const hpatch_StreamPos_t cancelSizeOnCancelCompress=0){
-                TPlaceholder nullPos(0,0); return pushStream(stream,compressPlugin,nullPos,
-                                                             isMustCompress,cancelSizeOnCancelCompress); }
-    hpatch_StreamPos_t pushStream(const hpatch_TStreamInput* stream){
-                _pushStream(stream); return stream->streamSize; }
+    void pushStream(const hpatch_TStreamInput*   stream,
+                    const hdiff_TCompress*       compressPlugin,
+                    const TPlaceholder&          update_compress_sizePos);
+    void pushStream(const hpatch_TStreamInput* stream){
+                            TPlaceholder nullPos(0,0); pushStream(stream,0,nullPos); }
     hpatch_StreamPos_t getWritedPos()const{ return writePos; }
-    void stream_read(const TPlaceholder& pos,hpatch_byte* out_data);
-    inline TPlaceholder pushBack_pos(const hpatch_byte* src,size_t n){
-        hpatch_StreamPos_t pos=writePos;
-        pushBack(src,n);
-        return TPlaceholder(pos,writePos);
-    }
-    void stream_update(const TPlaceholder& pos,const hpatch_byte* in_data);
 private:
     const hpatch_TStreamOutput*  out_diff;
     hpatch_StreamPos_t     writePos;
-    enum{ kBufSize=hdiff_kFileIOBufBestSize };
+    enum{ kBufSize=hpatch_kFileIOBufBetterSize };
     TAutoMem               _temp_mem;
     
     void _packUInt_limit(hpatch_StreamPos_t uValue,size_t limitOutSize);
@@ -257,43 +115,25 @@ private:
     void _pushStream(const hpatch_TStreamInput* stream);
 };
 
-struct TVectorAsStreamOutput:public hpatch_TStreamOutput{
-    explicit TVectorAsStreamOutput(std::vector<unsigned char>& _dst);
-    std::vector<unsigned char>& dst;
-};
-struct TVectorAsStreamInput:public hpatch_TStreamInput{
-    explicit TVectorAsStreamInput(const std::vector<unsigned char>& _src)
-    :src(_src){ mem_as_hStreamInput(this,src.data(),src.data()+src.size()); }
-    const std::vector<unsigned char>& src;
-};
-
-
 
-#define _test_rt(value) { if (!(value)) { LOG_ERR("check "#value" error!\n");  return hpatch_FALSE; } }
-
-struct _TCheckOutNewDataStream:public hpatch_TStreamOutput{
-    _TCheckOutNewDataStream(const hpatch_TStreamInput* _newData,unsigned char* _buf,size_t _bufSize);
-    bool isWriteFinish()const{ return writedLen==newData->streamSize; }
+class TStreamClip:public hpatch_TStreamInput{
+public:
+    explicit TStreamClip(const hpatch_TStreamInput* stream,
+                         hpatch_StreamPos_t clipBeginPos,hpatch_StreamPos_t clipEndPos,
+                         hpatch_TDecompress* decompressPlugin=0,hpatch_StreamPos_t uncompressSize=0);
+    ~TStreamClip();
 private:
-    const hpatch_TStreamInput*  newData;
-    hpatch_StreamPos_t          writedLen;
-    unsigned char*              buf;
-    size_t                      bufSize;
-    static hpatch_BOOL _read_writed(const struct hpatch_TStreamOutput* stream,hpatch_StreamPos_t readFromPos,
-                                    unsigned char* out_data,unsigned char* out_data_end);
-    static hpatch_BOOL _write_check(const hpatch_TStreamOutput* stream,hpatch_StreamPos_t writeToPos,
-                                    const unsigned char* data,const unsigned char* data_end);
+    const hpatch_TStreamInput*  _src;
+    const hpatch_StreamPos_t    _src_begin;
+    const hpatch_StreamPos_t    _src_end;
+    hpatch_TDecompress*         _decompressPlugin;
+    hpatch_decompressHandle     _decompressHandle;
+    hpatch_StreamPos_t          _read_uncompress_pos;
+    void closeDecompressHandle();
+    void openDecompressHandle();
+    static hpatch_BOOL _clip_read(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                                  unsigned char* out_data,unsigned char* out_data_end);
 };
 
-
-void do_compress(std::vector<unsigned char>& out_code,const hpatch_TStreamInput* data,
-                 const hdiff_TCompress* compressPlugin,bool isMustCompress=false);
-static inline void do_compress(std::vector<unsigned char>& out_code,const std::vector<unsigned char>& data,
-                               const hdiff_TCompress* compressPlugin,bool isMustCompress=false){
-    hpatch_TStreamInput dataStream;
-    mem_as_hStreamInput(&dataStream,data.data(),data.data()+data.size());
-    do_compress(out_code,&dataStream,compressPlugin,isMustCompress);
-}
-
 }//namespace hdiff_private
 #endif

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

@@ -31,33 +31,30 @@
 #include <stdlib.h> //malloc free
 #include <string.h> //size_t
 #include <stdexcept>  //std::runtime_error
-#include <string>
 namespace hdiff_private{
 
     struct TAutoMem{
-        inline explicit TAutoMem(size_t size=0) :_data(0),_data_end(0),_capacity_end(0){ realloc(size); }
+        inline explicit TAutoMem(size_t size=0) :_data(0),_data_end(0){ realloc(size); }
         inline ~TAutoMem(){ clear(); }
         inline unsigned char* data(){ return _data; }
         inline const unsigned char* data()const{ return _data; }
         inline unsigned char* data_end(){ return _data_end; }
         inline const unsigned char* data_end()const{ return _data_end; }
         inline size_t size()const{ return (size_t)(_data_end-_data); }
-        inline size_t capacity()const{ return (size_t)(_capacity_end-_data); }
         inline bool empty()const{ return (_data_end==_data); }
-        inline void clear(){ if (_data) { free(_data); _data=0; _data_end=0; _capacity_end=0; } }
+        inline void clear(){ if (_data) { free(_data); _data=0; _data_end=0; } }
         inline void realloc(size_t newSize){
-            if (newSize<=capacity()){
-                _data_end=_data+newSize;
-            }else{
-                unsigned char* _new_data=(unsigned char*)::realloc(_data,newSize);
-                if (_new_data==0) throw std::runtime_error("TAutoMem::TAutoMem() realloc() error!");
-                _data=_new_data;
-                _data_end=_new_data+newSize;
-                _capacity_end=_data_end;
+            if (newSize!=size()){
+                clear();
+                if (newSize>0){
+                    _data=(unsigned char*)malloc(newSize);
+                    if (0==_data) throw std::runtime_error("TAutoMem::TAutoMem() malloc() error!");
+                    _data_end=_data+newSize;
+                }
             }
         }
         inline void reduceSize(size_t reserveSize){
-            if (reserveSize<=capacity())
+            if (reserveSize<=size())
                 _data_end=_data+reserveSize;
             else
                 throw std::runtime_error("TAutoMem::reduceSize() error!");
@@ -65,7 +62,6 @@ namespace hdiff_private{
     private:
         unsigned char*  _data;
         unsigned char*  _data_end;
-        unsigned char*  _capacity_end;
     };
 
 }//namespace hdiff_private

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

@@ -35,16 +35,18 @@
 #include <string>
 namespace hdiff_private{
 
-inline static void packUIntWithTag(std::vector<unsigned char>& out_code,hpatch_StreamPos_t uValue,
+template<class _UInt>
+inline static void packUIntWithTag(std::vector<unsigned char>& out_code,_UInt uValue,
                                    int highTag,const int kTagBit){
     unsigned char  codeBuf[hpatch_kMaxPackedUIntBytes];
     unsigned char* codeEnd=codeBuf;
     if (!hpatch_packUIntWithTag(&codeEnd,codeBuf+hpatch_kMaxPackedUIntBytes,uValue,highTag,kTagBit))
-        throw std::runtime_error("packUIntWithTag() hpatch_packUIntWithTag() error!");
+        throw std::runtime_error("packUIntWithTag<_UInt>() hpatch_packUIntWithTag() error!");
     out_code.insert(out_code.end(),codeBuf,codeEnd);
 }
 
-inline static void packUInt(std::vector<unsigned char>& out_code,hpatch_StreamPos_t uValue){
+template<class _UInt>
+inline static void packUInt(std::vector<unsigned char>& out_code,_UInt uValue){
     packUIntWithTag(out_code,uValue,0,0);
 }
 
@@ -59,23 +61,7 @@ inline static void pushBack(std::vector<unsigned char>& out_buf,
 inline static void pushBack(std::vector<unsigned char>& out_buf,const std::vector<unsigned char>& data){
     out_buf.insert(out_buf.end(),data.begin(),data.end());
 }
-
-static void pushBack(std::vector<unsigned char>& out_buf,const hpatch_TStreamInput* data){
-    const size_t kStepSize=hpatch_kStreamCacheSize*2;
-    unsigned char buf[kStepSize];
-    out_buf.reserve(out_buf.size()+(size_t)data->streamSize);
-    hpatch_StreamPos_t curPos=0;
-    while (curPos<data->streamSize){
-        size_t len=kStepSize;
-        if (curPos+len>data->streamSize)
-            len=(size_t)(data->streamSize-curPos);
-        if (!data->read(data,curPos,buf,buf+len))
-            throw std::runtime_error("pushBack() data->read() error!");
-        pushBack(out_buf,buf,len);
-        curPos+=len;
-    }
-}
-
+    
     
 template <class TUInt> inline static
 void pushUInt(std::vector<unsigned char>& out_buf,TUInt v){
@@ -88,7 +74,7 @@ void pushUInt(std::vector<unsigned char>& out_buf,TUInt v){
 }
 
 inline static
-void pushByte(std::vector<unsigned char>& out_buf,unsigned char v){
+void pushUInt(std::vector<unsigned char>& out_buf,unsigned char v){
     out_buf.insert(out_buf.end(),v);
 }
 
@@ -108,7 +94,6 @@ struct TPlaceholder{
     inline TPlaceholder(hpatch_StreamPos_t _pos,hpatch_StreamPos_t _pos_end)
     :pos(_pos),pos_end(_pos_end){ assert(_pos<=_pos_end); }
     inline hpatch_StreamPos_t size()const{ return pos_end-pos; }
-    inline bool isNullPos()const{ return (pos_end==0)&&(pos_end==pos); }
 };
 
 hpatch_inline static