react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_client/sync_client.h

@@ -1,74 +0,0 @@
-//  sync_client.h
-//  sync_client
-//  Created by housisong on 2019-09-18.
-/*
- The MIT License (MIT)
- Copyright (c) 2019-2023 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 sync_client_h
-#define sync_client_h
-#include "sync_info_client.h"
-
-//sync_patch(oldStream+syncDataListener) to out_newStream
-TSyncClient_resultType sync_patch(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
-                                  const hpatch_TStreamInput* oldStream,const TNewDataSyncInfo* newSyncInfo,
-                                  const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,
-                                  const hpatch_TStreamOutput* out_diffInfoStream,const hpatch_TStreamInput* diffInfoContinue,int threadNum);
-
-//sync patch(oldFile+syncDataListener) to outNewFile
-TSyncClient_resultType sync_patch_file2file(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
-                                            const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
-                                            const char* outNewFile,hpatch_BOOL isOutNewContinue,
-                                            const char* cacheDiffInfoFile,int threadNum);
-
-
-//sync_patch can split to two steps: sync_local_diff + sync_local_patch
-
-
-//download diff data from syncDataListener to out_diffStream
-//  if (diffContinue) then continue download
-TSyncClient_resultType sync_local_diff(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
-                                       const hpatch_TStreamInput* oldStream,const TNewDataSyncInfo* newSyncInfo,
-                                       const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
-                                       const hpatch_TStreamInput* diffContinue,int threadNum);
-
-//patch(oldStream+in_diffStream) to out_newStream
-TSyncClient_resultType sync_local_patch(ISyncInfoListener* listener,const hpatch_TStreamInput* in_diffStream,
-                                        const hpatch_TStreamInput* oldStream,const TNewDataSyncInfo* newSyncInfo,
-                                        const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,int threadNum);
-
-
-//download diff data from syncDataListener to outDiffFile
-//  if (isOutDiffContinue) then continue download
-TSyncClient_resultType sync_local_diff_file2file(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
-                                                 const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
-                                                 const char* outDiffFile,TSyncDiffType diffType,
-                                                 hpatch_BOOL isOutDiffContinue,int threadNum);
-
-//patch(oldFile+inDiffFile) to outNewFile
-TSyncClient_resultType sync_local_patch_file2file(ISyncInfoListener* listener,const char* inDiffFile,
-                                                  const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
-                                                  const char* outNewFile,hpatch_BOOL isOutNewContinue,int threadNum);
-
-#endif // sync_client_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_client/sync_client_private.h

@@ -1,262 +0,0 @@
-//  sync_client_private.h
-//  sync_client
-//  Created by housisong on 2020-02-09.
-/*
- The MIT License (MIT)
- Copyright (c) 2019-2020 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 sync_client_private_h
-#define sync_client_private_h
-#include "sync_client_type_private.h"
-#include "sync_client.h"
-#include "match_in_old.h"
-#include "match_in_types.h"
-#include "../../libHDiffPatch/HDiff/private_diff/mem_buf.h"
-#include "../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/bloom_filter.h"
-struct hpatch_TFileStreamOutput;
-using namespace hdiff_private;
-namespace sync_private{
-    struct TSyncDiffData;
-
-    TSyncClient_resultType
-        _sync_patch(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,TSyncDiffData* diffData,
-                    const hpatch_TStreamInput* oldStream,const TNewDataSyncInfo* newSyncInfo,
-                    const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,
-                    const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
-                    const hpatch_TStreamInput* diffContinue,int threadNum);
-
-    
-    struct _TWriteDatas {
-        const hpatch_TStreamOutput* out_newStream;
-        const hpatch_TStreamInput*  newDataContinue;
-        const hpatch_TStreamOutput* out_diffStream;
-        hpatch_StreamPos_t          outDiffDataPos;
-        const hpatch_TStreamInput*  oldStream;
-        const TNewDataSyncInfo*     newSyncInfo;
-        const TNeedSyncInfos*       needSyncInfo;
-        const hpatch_StreamPos_t*   newBlockDataInOldPoss;
-        TSyncDiffData*              continueDiffData;
-        uint32_t                    needSyncBlockCount;
-        bool                        isNeed_readSyncDataEnd;
-        bool                        isLocalPatch;
-        hpatch_checksumHandle       checkChecksum;
-        hsync_TDictDecompress*      decompressPlugin;
-        IReadSyncDataListener*      syncDataListener;
-    };
-    
-    struct _ISyncPatch_by{
-        void  (*matchNewDataInOld)(hpatch_StreamPos_t* out_newBlockDataInOldPoss,const TNewDataSyncInfo* newSyncInfo,
-                                   const hpatch_TStreamInput* oldStream,int threadNum);
-        TSyncClient_resultType (*writeToNewOrDiff)(_TWriteDatas& wd);
-        void  (*checkChecksumInit)(unsigned char* checkChecksumBuf,size_t checksumByteSize);
-        void (*checkChecksumEndTo)(unsigned char* dst,unsigned char* checkChecksumBuf,
-                                   hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum);
-    };
-
-    TSyncClient_resultType 
-        _sync_patch_by(_ISyncPatch_by* sp_by,
-                       ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,TSyncDiffData* diffData,
-                       const hpatch_TStreamInput* oldStream,const TNewDataSyncInfo* newSyncInfo,
-                       const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,
-                       const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
-                       const hpatch_TStreamInput* diffContinue,int threadNum);
-
-    bool _open_continue_out(hpatch_BOOL& isOutContinue,const char* outFile,hpatch_TFileStreamOutput* out_stream,
-                            hpatch_TStreamInput* continue_stream,hpatch_StreamPos_t maxContinueLength=hpatch_kNullStreamPos);
-
-    struct _TMatchDatas{
-        hpatch_StreamPos_t*         out_newBlockDataInOldPoss;
-        const TNewDataSyncInfo*     newSyncInfo;
-        const hpatch_TStreamInput*  oldStream;
-        void*               filter;
-        const uint32_t*     sorted_newIndexs;
-        const uint32_t*     sorted_newIndexs_table;
-        unsigned int        kTableHashShlBit;
-        uint32_t            threadNum;
-        void (*rollMatch)(_TMatchDatas& rd,hpatch_StreamPos_t oldRollBegin,hpatch_StreamPos_t oldRollEnd,void* _mt);
-        const uint32_t* (*getSortedIndexs)(TAutoMem& _mem_sorted,const TNewDataSyncInfo* newSyncInfo,void* filter);
-    };
-
-    
-    template<class TFilter_t> static hpatch_inline
-    const uint32_t* _tm_getSortedIndexs(TAutoMem& _mem_sorted,const TNewDataSyncInfo* newSyncInfo,
-                                        TFilter_t& filter){
-        const uint32_t kBlockCount=(uint32_t)TNewDataSyncInfo_blockCount(newSyncInfo);
-        const uint32_t kMatchBlockCount=kBlockCount-newSyncInfo->samePairCount;
-        const size_t savedRollHashByteSize=newSyncInfo->savedRollHashByteSize;
-        const size_t needRollHashByteSize=savedRollHashByteSize*(newSyncInfo->isSeqMatch?2:1);
-        typedef typename TFilter_t::value_type filter_value_t;
-        _mem_sorted.realloc(kMatchBlockCount*(size_t)sizeof(uint32_t));
-        uint32_t* sorted_newIndexs=(uint32_t*)_mem_sorted.data();
-
-        const uint8_t* partRollHash=newSyncInfo->rollHashs;
-        uint32_t curPair=0;
-        uint32_t indexi=0;
-        for (uint32_t i=0;i<kBlockCount;++i,partRollHash+=savedRollHashByteSize){
-            if ((curPair<newSyncInfo->samePairCount)&&(i==newSyncInfo->samePairList[curPair].curIndex)){
-                ++curPair;
-            }else{
-                sorted_newIndexs[indexi++]=i;
-                filter.insert((filter_value_t)readRollHashBytes(partRollHash,needRollHashByteSize));
-            }
-        }
-        assert(indexi==kMatchBlockCount);
-        assert(curPair==newSyncInfo->samePairCount);
-
-        TIndex_comp01 icomp01(newSyncInfo->rollHashs,savedRollHashByteSize,
-                              newSyncInfo->partChecksums,newSyncInfo->savedStrongChecksumByteSize,newSyncInfo->isSeqMatch);
-        std::sort(sorted_newIndexs,sorted_newIndexs+kMatchBlockCount,icomp01);
-        return sorted_newIndexs;
-    }
-
-    static inline void _init_newBlockDataInOldPoss(hpatch_StreamPos_t* newBlockDataInOldPoss,uint32_t kBlockCount){
-                            for (uint32_t i=0; i<kBlockCount; ++i) newBlockDataInOldPoss[i]=kBlockType_needSync; }
-    static inline void _end_newBlockDataInOldPoss(hpatch_StreamPos_t* newBlockDataInOldPoss,uint32_t kBlockCount,
-                                                  hpatch_StreamPos_t oldSize){
-                            for (uint32_t i=0; i<kBlockCount; ++i){
-                                hpatch_StreamPos_t& pos=newBlockDataInOldPoss[i];
-                                pos=(pos<oldSize)?pos:kBlockType_needSync;
-                            } }
-
-#if (_IS_USED_MULTITHREAD)
-    struct _TMatchDatas;
-    namespace{
-        struct TMt:public TMtByChannel{
-            inline explicit TMt(struct _TMatchDatas& _matchDatas)
-                :matchDatas(_matchDatas),workIndex(0){}
-            CHLocker readLocker;
-            CHLocker writeLocker;
-        #if (_IS_USED_CPP_ATOMIC)
-            std::atomic<size_t>  workIndex;
-        #else
-            CHLocker         workiLocker;
-            volatile size_t  workIndex;
-            inline bool getWorki(size_t worki){
-                if (workIndex>worki) return false;
-                CAutoLocker _auto_locker(workiLocker.locker);
-                if (workIndex==worki){
-                    ++workIndex;
-                    return true;
-                }else
-                    return false;
-            }
-        #endif
-            struct _TMatchDatas& matchDatas;
-        };
-    }
-
-    void _rollMatch_mt(int threadIndex,void* workData);
-
-#endif
-
-    struct TStreamDataCache_base;
-    bool _matchRange(hpatch_StreamPos_t* out_newBlockDataInOldPoss,const uint32_t* range_begin,const uint32_t* range_end,
-                     TStreamDataCache_base& oldData,const TNewDataSyncInfo* newSyncInfo,hpatch_StreamPos_t kMinRevSameIndex,void* _mt);
-
-
-    template<class TOldDataRoll_t,class TFilter_t,bool isSeqMatch,class TFunc_savedPartRollHash>
-    static hpatch_inline
-    void _tm_rollMatch(_TMatchDatas& rd,hpatch_StreamPos_t oldRollBegin,hpatch_StreamPos_t oldRollEnd,
-                       TFunc_savedPartRollHash f_toSavedPartRollHash,void* _mt){
-        const uint32_t kBlockCount=(uint32_t)TNewDataSyncInfo_blockCount(rd.newSyncInfo);
-        const hpatch_StreamPos_t kMinRevSameIndex=kBlockType_needSync-1-kBlockCount;
-        const size_t savedRollHashByteSize=rd.newSyncInfo->savedRollHashByteSize;
-        assert(isSeqMatch==(rd.newSyncInfo->isSeqMatch!=0));
-        const size_t needRollHashByteSize=savedRollHashByteSize*(isSeqMatch?2:1);
-        TIndex_comp0 icomp0(rd.newSyncInfo->rollHashs,savedRollHashByteSize);
-        TIndex_comp0 icomp0_s(rd.newSyncInfo->rollHashs,savedRollHashByteSize,isSeqMatch);
-        assert(oldRollBegin<oldRollEnd);
-        TOldDataRoll_t  oldData(rd.oldStream,oldRollBegin,oldRollEnd,
-                                rd.newSyncInfo->kSyncBlockSize,rd.newSyncInfo->strongChecksumPlugin
-                            #if (_IS_USED_MULTITHREAD)
-                                ,_mt?((TMt*)_mt)->readLocker.locker:0
-                            #endif
-                                );
-        uint8_t part[sizeof(tm_roll_uint)]={0};
-        const size_t savedRollHashBits=rd.newSyncInfo->savedRollHashBits;
-        const TFilter_t& filter=*(TFilter_t*)rd.filter;
-        typedef typename TFilter_t::value_type filter_value_t;
-        tm_roll_uint digestFull_back=~oldData.hashValue(); //not same digest
-        hpatch_StreamPos_t curOldPos=oldData.curStreamPos();
-        hpatch_StreamPos_t _matchedPosBack=isSeqMatch?curOldPos:~(hpatch_StreamPos_t)0;
-        while (true) {
-            if (isSeqMatch) curOldPos=oldData.curStreamPos();
-            tm_roll_uint digest=oldData.hashValue();
-            if (digestFull_back!=digest){
-                digestFull_back=digest;
-                digest=f_toSavedPartRollHash(digest,savedRollHashBits);
-                if ((!isSeqMatch)||(_matchedPosBack!=curOldPos)){
-                    if (!filter.is_hit((filter_value_t)digest))
-                        { if (oldData.roll()) continue; else break; }//finish
-                }
-            }else{
-                if (oldData.roll()) continue; else break; //finish
-            }
-            
-            const uint32_t* ti_pos0;
-            const uint32_t* ti_pos1;
-            if ((!isSeqMatch)||((savedRollHashBits<=rd.kTableHashShlBit)||(_matchedPosBack!=curOldPos))){
-                const uint32_t* ti_pos=&rd.sorted_newIndexs_table[digest>>rd.kTableHashShlBit];
-                ti_pos0=rd.sorted_newIndexs+ti_pos[0];
-                ti_pos1=rd.sorted_newIndexs+ti_pos[1];
-            }else{
-                digest=digest>>savedRollHashBits<<savedRollHashBits; //remove next rollHash
-                ti_pos0=rd.sorted_newIndexs+rd.sorted_newIndexs_table[digest>>rd.kTableHashShlBit];
-                digest=digest|((1<<savedRollHashBits)-1);
-                ti_pos1=rd.sorted_newIndexs+rd.sorted_newIndexs_table[(digest>>rd.kTableHashShlBit)+1];
-            }
-            writeRollHashBytes(part,digest,needRollHashByteSize);
-            TIndex_comp0::TDigest digest_value(part);
-            const TIndex_comp0& _icomp0=((!isSeqMatch)||(_matchedPosBack!=curOldPos))?icomp0_s:icomp0;
-            std::pair<const uint32_t*,const uint32_t*>
-            //range=std::equal_range(rd.sorted_newIndexs,rd.sorted_newIndexs+(kBlockCount-rd.newSyncInfo->samePairCount),digest_value,_icomp0);
-            range=std::equal_range(ti_pos0,ti_pos1,digest_value,_icomp0);
-            if (range.first==range.second)
-                { if (oldData.roll()) continue; else break; }//finish
-
-            bool isMatched=_matchRange(rd.out_newBlockDataInOldPoss,range.first,range.second,oldData,
-                                       rd.newSyncInfo,kMinRevSameIndex,_mt);
-            if (isMatched){
-                if (!isSeqMatch) curOldPos=oldData.curStreamPos();
-                _matchedPosBack=curOldPos+rd.newSyncInfo->kSyncBlockSize;
-                if (kIsSkipMatchedBlock){
-                    if (oldData.nextBlock()) { digestFull_back=~oldData.hashValue(); continue; } else break;
-                }//else roll
-            }//else roll
-            if (oldData.roll()) continue; else break;
-        }
-    }
-
-    void _matchNewDataInOld(_TMatchDatas& matchDatas,int threadNum);
-    
-    struct _IWriteToNewOrDiff_by{
-        void (*checkChecksumAppendData)(unsigned char* checkChecksumBuf,uint32_t checksumIndex,
-                                        hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum,
-                                        const unsigned char* blockChecksum,const unsigned char* blockData,size_t blockDataSize);
-    };
-    TSyncClient_resultType _writeToNewOrDiff_by(_IWriteToNewOrDiff_by* wr_by,_TWriteDatas& wd);
-
-}//namespace sync_private
-
-#endif // sync_client_private_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_client/sync_client_type.h

@@ -1,174 +0,0 @@
-//  sync_client_type.h
-//  sync_client
-//  Created by housisong on 2019-09-17.
-/*
- The MIT License (MIT)
- Copyright (c) 2019-2020 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 sync_client_type_h
-#define sync_client_type_h
-#include "../../libHDiffPatch/HPatch/patch_types.h"
-#include "../../libHDiffPatch/HPatch/checksum_plugin.h"
-#include "../../dirDiffPatch/dir_patch/dir_patch_types.h"
-#include "dict_decompress_plugin.h"
-#include <stdint.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-static const size_t kDecompressInfoMaxSize = 32;
-static const size_t _kNeedMinRollHashBits   = 8;
-static const size_t _kNeedMinStrongHashBits = 16;
-static const size_t kSafeHashClashBit_min   = 14; //for safe
-static const uint32_t _kSyncBlockSize_min_limit = 64;
-static const uint32_t _kStrongChecksumByteSize_max_limit=1024*64/8;
-
-hpatch_inline static
-hpatch_StreamPos_t getSyncBlockCount(hpatch_StreamPos_t newDataSize,uint32_t kSyncBlockSize){
-    return (newDataSize+(kSyncBlockSize-1))/kSyncBlockSize; }
-
-
-typedef struct TSameNewBlockPair{
-    uint32_t  curIndex;
-    uint32_t  sameIndex; // sameIndex < curIndex;
-} TSameNewBlockPair;
-
-
-#if (_IS_NEED_DIR_DIFF_PATCH)
-typedef struct{
-    size_t                  dir_newPathCount;
-    uint8_t                 dir_newNameList_isCString;
-    const void*             dir_utf8NewNameList;//is const char** or const std::string* type
-    const char*             dir_utf8NewRootPath;
-    hpatch_StreamPos_t*     dir_newSizeList;
-    size_t                  dir_newPathSumCharSize;
-    size_t                  dir_newExecuteCount;
-    size_t*                 dir_newExecuteIndexList;
-} TNewDataSyncInfo_dir;
-#endif
-
-typedef struct{
-  uint32_t bitsSize                 : (32-3);
-  uint32_t skipBitsInFirstCodeByte  : 3;
-} savedBitsInfo_t;
-
-
-typedef struct{
-    const char*             compressType;
-    const char*             strongChecksumType;
-    size_t                  savedStrongChecksumByteSize;
-    size_t                  savedRollHashByteSize;
-    size_t                  savedStrongChecksumBits;
-    size_t                  savedRollHashBits;
-    size_t                  dictSize;
-    uint32_t                kSyncBlockSize;
-    uint32_t                samePairCount;
-    uint8_t                 isDirSyncInfo;
-    uint8_t                 isNotCChecksumNewMTParallel; // not run checkChecksum newData in parallel? default is false(run parallel)
-    uint8_t                 isSeqMatch;//default is false
-    uint8_t                 isSavedBitsSizes;//default is false & savedSizes is bytes size; if true, savedSizes is bits size;
-    uint8_t                 decompressInfoSize;
-    uint8_t                 decompressInfo[kDecompressInfoMaxSize];
-    hpatch_StreamPos_t      newDataSize;      // newData version size;
-    hpatch_StreamPos_t      newSyncDataSize;  // .hsynz size ,saved newData or complessed newData
-    hpatch_StreamPos_t      newSyncDataOffsert;
-    hpatch_StreamPos_t      newSyncInfoSize;  // .hsyni size ,saved newData's info
-    hpatch_StreamPos_t      infoChecksumEndPos; //saved infoChecksum data end pos in stream
-    unsigned char*          savedNewDataCheckChecksum; // out new data's strongChecksum's checksum
-    unsigned char*          infoChecksum; // this info data's strongChecksum
-    unsigned char*          infoPartHashChecksum; // this info data's strongChecksum
-    TSameNewBlockPair*      samePairList;
-    union{
-        uint32_t*           savedSizes;
-        savedBitsInfo_t*    savedBitsInfos;
-    };
-    uint8_t*                rollHashs;
-    uint8_t*                partChecksums;
-#if (_IS_NEED_DIR_DIFF_PATCH)
-    TNewDataSyncInfo_dir    dirInfo;
-    size_t                  dirInfoSavedSize;
-#endif
-    hpatch_TChecksum*       strongChecksumPlugin;
-    hpatch_TChecksum*       fileChecksumPlugin;
-    hsync_TDictDecompress*  _decompressPlugin;
-    void*                   _import;
-    void*                   _extraMem;
-} TNewDataSyncInfo;
-
-#define _bitsToBytes(bits) (((bits)+7)>>3)
-
-struct TNeedSyncInfos;
-//out_skipBitsInFirstCodeByte&out_lastByteHalfBits can null, only for zsync;
-typedef void (*TSync_getBlockInfoByIndex)(const struct TNeedSyncInfos* needSyncInfos,uint32_t blockIndex,
-                                          hpatch_BOOL* out_isNeedSync,uint32_t* out_syncSize,
-                                          hpatch_byte* out_skipBitsInFirstCodeByte,hpatch_byte* out_lastByteHalfBits);
-typedef struct TNeedSyncInfos{
-    hpatch_StreamPos_t          newDataSize;     // new data size
-    hpatch_StreamPos_t          localNewDataSize; // local new file size for download continue
-    hpatch_StreamPos_t          newSyncDataSize; // new data size or .hsynz file size
-    hpatch_StreamPos_t          newSyncInfoSize; // .hsyni file size
-    hpatch_StreamPos_t          localDiffDataSize; // local diff data size for download continue
-    hpatch_StreamPos_t          needSyncSumSize; // all need download from new data or .hsynz file
-    uint32_t                    kSyncBlockSize;
-    uint32_t                    blockCount;
-    uint32_t                    needSyncBlockCount;
-    TSync_getBlockInfoByIndex   getBlockInfoByIndex;
-    void*                       import; //private
-} TNeedSyncInfos;
-
-size_t TNeedSyncInfos_getNextRanges(const TNeedSyncInfos* nsi,hpatch_StreamPos_t* dstRanges,size_t maxGetRangeLen,
-                                    uint32_t* curBlockIndex,hpatch_StreamPos_t* curPosInNewSyncData,uint32_t isReLoadNewHalf);
-static hpatch_inline
-size_t TNeedSyncInfos_getRangeCount(const TNeedSyncInfos* nsi,uint32_t curBlockIndex,
-                                    hpatch_StreamPos_t curPosInNewSyncData,uint32_t isReLoadNewHalf){
-    return TNeedSyncInfos_getNextRanges(nsi,0,~(size_t)0,&curBlockIndex,&curPosInNewSyncData,isReLoadNewHalf); }
-
-typedef struct IReadSyncDataListener{
-    void*       readSyncDataImport;
-    //onNeedSyncInfo can null
-    void        (*onNeedSyncInfo)   (struct  IReadSyncDataListener* listener,const TNeedSyncInfos* needSyncInfo);
-    //readSyncDataBegin can null
-    hpatch_BOOL (*readSyncDataBegin)(struct  IReadSyncDataListener* listener,const TNeedSyncInfos* needSyncInfo,
-                                     uint32_t blockIndex,hpatch_StreamPos_t posInNewSyncData,uint32_t isReLoadNewHalf,
-                                     hpatch_StreamPos_t posInNeedSyncData,uint32_t isReLoadDiffHalf);
-    //download range data; isReLoadNewHalf&isReLoadDiffHalf is 0 or 1; if 1, reload the last byte of prev block.
-    hpatch_BOOL (*readSyncData)     (struct IReadSyncDataListener* listener,uint32_t blockIndex,
-                                     hpatch_StreamPos_t posInNewSyncData,uint32_t isReLoadNewHalf,
-                                     hpatch_StreamPos_t posInNeedSyncData,uint32_t isReLoadDiffHalf,
-                                     unsigned char* out_syncDataBuf,uint32_t syncDataSize);
-    //readSyncDataEnd can null
-    void        (*readSyncDataEnd)  (struct IReadSyncDataListener* listener);
-} IReadSyncDataListener;
-
-typedef enum TSyncDiffType{
-    kSyncDiff_default=0, // out diff (info+data)
-    kSyncDiff_info,      // out diff info, for optimize continue speed
-    kSyncDiff_data,      // out diff data, for test download file size; NOTE: now only support run with single thread
-} TSyncDiffType;
-#define _kSyncDiff_TYPE_MAX_ kSyncDiff_data
-
-#ifdef __cplusplus
-}
-#endif
-#endif //sync_client_type_h