@bravemobile/react-native-code-push 12.4.1 → 13.1.0-beta.0

package/cpp/binarypatch/vendor/HDiffPatch/libHDiffPatch/HPatch/patch.h

@@ -0,0 +1,268 @@
+//patch.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 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 HPatch_patch_h
+#define HPatch_patch_h
+#include "patch_types.h"
+#include "hpatch_mt/hpatch_mt.h"
+#include "checksum_plugin.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
+
+
+//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
+//  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
+
+//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,
+                                  const hpatch_TStreamInput* compressedDiff);
+//see getCompressedDiffInfo()
+hpatch_inline static hpatch_BOOL
+    getCompressedDiffInfo_mem(hpatch_compressedDiffInfo* out_diffInfo,
+                              const unsigned char* compressedDiff,
+                              const unsigned char* compressedDiff_end){
+        hpatch_TStreamInput  diffStream;
+        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)
+//  compressedDiff create by create_compressed_diff() or create_compressed_diff_stream()
+//  decompressPlugin can be null when there is no compressed data in compressedDiff
+//  if using patch_decompress_with_cache(), a larger memory cache can be passed to optimize speed
+hpatch_BOOL patch_decompress(const hpatch_TStreamOutput* out_newData,       //sequential write
+                             const hpatch_TStreamInput*  oldData,           //random read
+                             const hpatch_TStreamInput*  compressedDiff,    //random read
+                             hpatch_TDecompress* decompressPlugin);
+
+//see patch_decompress()
+//  can passing larger memory cache to optimize speed
+//  note: (temp_cache_end-temp_cache)>=2048
+hpatch_BOOL patch_decompress_with_cache(const hpatch_TStreamOutput* out_newData,    //sequential write
+                                        const hpatch_TStreamInput*  oldData,        //random read
+                                        const hpatch_TStreamInput*  compressedDiff, //random read
+                                        hpatch_TDecompress* decompressPlugin,
+                                        unsigned char* temp_cache,unsigned char* temp_cache_end);
+
+//see patch_decompress()
+hpatch_inline static hpatch_BOOL
+    patch_decompress_mem(unsigned char* out_newData,unsigned char* out_newData_end,
+                         const unsigned char* oldData,const unsigned char* oldData_end,
+                         const unsigned char* compressedDiff,const unsigned char* compressedDiff_end,
+                         hpatch_TDecompress* decompressPlugin){
+        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,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);
+hpatch_inline static
+hpatch_BOOL hpatch_coverList_close(hpatch_TCoverList* coverList) {
+                                   hpatch_BOOL result=hpatch_TRUE;
+                                   if ((coverList!=0)&&(coverList->ICovers)){
+                                       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 calling 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 be null when there is no compressed data in singleCompressedDiff
+//  same as calling 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,
+                                         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);
+    }
+
+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;
+                                    );
+
+
+hpatch_BOOL getWindowDiffInfo(hpatch_windowDiffInfo*      out_diffInfo,
+                              const hpatch_TStreamInput*  windowDiff,   //sequential read
+                              hpatch_StreamPos_t diffInfo_pos//default 0, begin pos in windowDiff
+                              );
+
+TWindowPatchResult patch_window_diff(struct winpatch_listener_t*  listener,
+                                     const hpatch_TStreamOutput*  out_newData,         //sequential write
+                                     const hpatch_TStreamInput*   oldData,             //random read
+                                     const hpatch_TStreamInput*   windowDiff,          //sequential read
+                                     hpatch_StreamPos_t  diffInfo_pos, //default 0, begin pos in windowDiff
+                                     size_t             threadNum   //1 for single-threaded, 2..5 for MT I/O
+                                     );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/cpp/binarypatch/vendor/HDiffPatch/libHDiffPatch/HPatch/patch_private.h

@@ -0,0 +1,297 @@
+//  patch_private.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 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 HPatch_patch_private_h
+#define HPatch_patch_private_h
+
+#include "patch.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    
+//byte rle type , ctrl code: high 2bit + packedLen(6bit+...)
+typedef enum TByteRleType{
+    kByteRleType_rle0  = 0,    //00 rle 0  , data code:0 byte
+    kByteRleType_rle255= 1,    //01 rle 255, data code:0 byte
+    kByteRleType_rle   = 2,    //10 rle x(1--254), data code:1 byte (save x)
+    kByteRleType_unrle = 3     //11 n byte data, data code:n byte(save no rle data)
+} TByteRleType;
+    
+static const hpatch_uint kByteRleType_bit=2;
+    
+
+typedef struct _THDiffzHead{
+    hpatch_StreamPos_t coverCount;
+    
+    hpatch_StreamPos_t cover_buf_size;
+    hpatch_StreamPos_t compress_cover_buf_size;
+    hpatch_StreamPos_t rle_ctrlBuf_size;
+    hpatch_StreamPos_t compress_rle_ctrlBuf_size;
+    hpatch_StreamPos_t rle_codeBuf_size;
+    hpatch_StreamPos_t compress_rle_codeBuf_size;
+    hpatch_StreamPos_t newDataDiff_size;
+    hpatch_StreamPos_t compress_newDataDiff_size;
+    
+    hpatch_StreamPos_t typesEndPos;
+    hpatch_StreamPos_t compressSizeBeginPos;
+    hpatch_StreamPos_t headEndPos;
+    hpatch_StreamPos_t coverEndPos;
+} _THDiffzHead;
+    
+hpatch_BOOL read_diffz_head(hpatch_compressedDiffInfo* out_diffInfo,_THDiffzHead* out_head,
+                            const hpatch_TStreamInput* compressedDiff);
+
+// Stream Clip cache
+typedef struct TStreamCacheClip{
+    hpatch_StreamPos_t          streamPos;
+    hpatch_StreamPos_t          streamPos_end;
+    const hpatch_TStreamInput*  srcStream;
+    unsigned char*  cacheBuf;
+    hpatch_size_t   cacheBegin;
+    hpatch_size_t   cacheEnd;
+} TStreamCacheClip;
+
+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;
+    sclip->cacheBuf=aCache;
+    sclip->cacheBegin=cacheSize;
+    sclip->cacheEnd=cacheSize;
+}
+    
+#define _TStreamCacheClip_isFinish(sclip)     ( 0==_TStreamCacheClip_leaveSize(sclip) )
+#define _TStreamCacheClip_isCacheEmpty(sclip) ( (sclip)->cacheBegin==(sclip)->cacheEnd )
+#define _TStreamCacheClip_cachedSize(sclip)   ( (hpatch_size_t)((sclip)->cacheEnd-(sclip)->cacheBegin) )
+#define _TStreamCacheClip_leaveSize(sclip)   \
+            (  (hpatch_StreamPos_t)((sclip)->streamPos_end-(sclip)->streamPos)  \
+                + (hpatch_StreamPos_t)_TStreamCacheClip_cachedSize(sclip)  )
+#define _TStreamCacheClip_readPosOfSrcStream(sclip) ( \
+            (sclip)->streamPos - _TStreamCacheClip_cachedSize(sclip) )
+    
+hpatch_BOOL _TStreamCacheClip_updateCache(TStreamCacheClip* sclip);
+    
+hpatch_inline static //error return 0
+unsigned char* _TStreamCacheClip_accessData(TStreamCacheClip* sclip,hpatch_size_t readSize){
+    //assert(readSize<=sclip->cacheEnd);
+    if (readSize>_TStreamCacheClip_cachedSize(sclip)){
+        if (!_TStreamCacheClip_updateCache(sclip)) return 0;
+        if (readSize>_TStreamCacheClip_cachedSize(sclip)) return 0;
+    }
+    return &sclip->cacheBuf[sclip->cacheBegin];
+}
+
+#define _TStreamCacheClip_skipData_noCheck(sclip,skipSize) ((sclip)->cacheBegin+=skipSize)
+hpatch_BOOL _TStreamCacheClip_skipData(TStreamCacheClip* sclip,hpatch_StreamPos_t skipLongSize);
+    
+hpatch_inline static //error return 0
+unsigned char* _TStreamCacheClip_readData(TStreamCacheClip* sclip,hpatch_size_t readSize){
+    unsigned char* result=_TStreamCacheClip_accessData(sclip,readSize);
+    _TStreamCacheClip_skipData_noCheck(sclip,readSize);
+    return result;
+}
+
+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_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);
+
+
+    typedef struct _TDecompressInputStream{
+        hpatch_TStreamInput         IInputStream;
+        hpatch_TDecompress*         decompressPlugin;
+        hpatch_decompressHandle     decompressHandle;
+    } _TDecompressInputStream;
+    
+hpatch_BOOL getStreamClip(TStreamCacheClip* out_clip,_TDecompressInputStream* out_stream,
+                          hpatch_StreamPos_t dataSize,hpatch_StreamPos_t compressedSize,
+                          const hpatch_TStreamInput* stream,hpatch_StreamPos_t* pCurStreamPos,
+                          hpatch_TDecompress* decompressPlugin,unsigned char* aCache,hpatch_size_t cacheSize);
+    
+
+#define _TDiffToSingleStream_kBufSize hpatch_kStreamCacheSize
+typedef struct {
+    hpatch_TStreamInput         base;
+    const hpatch_TStreamInput*  diffStream;
+    hpatch_StreamPos_t          readedSize;
+    hpatch_size_t               cachedBufBegin;
+    hpatch_BOOL                 isInSingleStream;
+    unsigned char               buf[_TDiffToSingleStream_kBufSize];
+} TDiffToSingleStream;
+
+void TDiffToSingleStream_init(TDiffToSingleStream* self,const hpatch_TStreamInput* diffStream);
+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
+hpatch_size_t _patch_is_can_cache_window_old_canUsedSize(hpatch_size_t windowOldBufSize,hpatch_size_t stepCoversMemSize,
+                                                         hpatch_size_t kMinTempCacheSize,hpatch_size_t tempCacheSize,hpatch_StreamPos_t oldDataSize);
+
+// ---- window overlap computation (shared by ST and MT) ----
+
+    typedef struct _oldwin_info_t{
+        hpatch_StreamPos_t oldPos;
+        hpatch_StreamPos_t len;
+    } _oldwin_info_t;
+
+typedef enum {
+    _kOverlapType_none = 0,       // no overlap (or no reuse)
+    _kOverlapType_contained,     // curr window fully contained in prev window
+    _kOverlapType_rightTail,     // curr starts inside prev, extends past prev end (tail overlap)
+    _kOverlapType_leftHead,      // curr starts before prev, ends inside prev (head overlap)
+    _kOverlapType_superset       // curr fully contains prev
+} _kOverlapType_t;
+
+static hpatch_inline _kOverlapType_t _compute_window_overlap(hpatch_StreamPos_t prevOldPos, hpatch_StreamPos_t prevOldEnd,
+                            hpatch_StreamPos_t currOldPos, hpatch_StreamPos_t currOldEnd,hpatch_StreamPos_t* out_reuseLen,
+                            hpatch_StreamPos_t* out_reuseOff,hpatch_StreamPos_t* out_noOverlapLeft){
+    hpatch_StreamPos_t oStart=(prevOldPos>currOldPos)?prevOldPos:currOldPos;
+    hpatch_StreamPos_t oEnd=(prevOldEnd<currOldEnd)?prevOldEnd:currOldEnd;
+    assert((prevOldPos<=prevOldEnd)&&(currOldPos<=currOldEnd));
+    if (oStart>=oEnd){
+        *out_reuseLen=0;
+        *out_reuseOff=0; // no value
+        *out_noOverlapLeft=0; // no value
+        return _kOverlapType_none; // no overlap
+    }else if ((currOldPos>=prevOldPos)&&(currOldEnd<=prevOldEnd)){// curr include prev (fully contained)
+        *out_reuseLen=currOldEnd-currOldPos;
+        *out_reuseOff=currOldPos-prevOldPos;
+        *out_noOverlapLeft=0;
+        return _kOverlapType_contained;
+    }else if ((currOldPos>=prevOldPos)&&(currOldPos<prevOldEnd)){// right-side/tail overlap
+        *out_reuseLen=prevOldEnd-currOldPos;
+        *out_reuseOff=currOldPos-prevOldPos;
+        *out_noOverlapLeft=0;
+        return _kOverlapType_rightTail;
+    }else if ((currOldEnd>prevOldPos)&&(currOldEnd<=prevOldEnd)){// left-side/head overlap
+        *out_reuseLen=currOldEnd-prevOldPos;
+        *out_reuseOff=0;
+        *out_noOverlapLeft=prevOldPos-currOldPos;
+        return _kOverlapType_leftHead;
+    }else{// curr contains prev (superset)
+        assert((currOldPos<prevOldPos)&&(currOldEnd>prevOldEnd));
+        *out_reuseLen=prevOldEnd-prevOldPos;
+        *out_reuseOff=0;
+        *out_noOverlapLeft=prevOldPos-currOldPos;
+        return _kOverlapType_superset;
+    }
+}
+
+#ifdef __cplusplus
+}
+#endif
+#endif