react-native-update 10.34.3 → 10.34.4

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

@@ -1,174 +0,0 @@
-//  sync_client_type_private.h
-//  sync_client
-//  Created by housisong on 2019-09-17.
-/*
- 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_type_private_h
-#define sync_client_type_private_h
-#include "sync_client_type.h"
-#include "../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.h"
-
-namespace sync_private{
-    
-hpatch_inline static
-hpatch_StreamPos_t TNewDataSyncInfo_blockCount(const TNewDataSyncInfo* self){
-        return getSyncBlockCount(self->newDataSize,self->kSyncBlockSize); }
-
-hpatch_inline static
-uint32_t TNewDataSyncInfo_newDataBlockSize(const TNewDataSyncInfo* self,uint32_t blockIndex){
-    const uint32_t kSyncBlockSize=self->kSyncBlockSize;
-    const hpatch_StreamPos_t endPos=kSyncBlockSize*((hpatch_StreamPos_t)blockIndex+1);
-    if (endPos<=self->newDataSize){
-        return kSyncBlockSize;
-    }else{
-        hpatch_StreamPos_t overLen=endPos-self->newDataSize;
-        assert(overLen<kSyncBlockSize);
-        return (overLen<kSyncBlockSize)?(kSyncBlockSize-(uint32_t)overLen):0;
-    }
-}
-hpatch_inline static
-bool TNewDataSyncInfo_syncBlockIsCompressed(const TNewDataSyncInfo* self,uint32_t blockIndex){
-    return (self->savedSizes)&&(self->savedSizes[blockIndex]);
-}
-
-hpatch_inline static
-//out_skipBitsInFirstCodeByte&out_lastByteHalfBits can null, only for zsync;
-uint32_t TNewDataSyncInfo_syncBlockSize(const TNewDataSyncInfo* self,uint32_t blockIndex,
-                                        hpatch_byte* out_skipBitsInFirstCodeByte,hpatch_byte* out_lastByteHalfBits){
-    assert((self->kSyncBlockSize*(hpatch_StreamPos_t)blockIndex)<self->newDataSize);
-    if (self->isSavedBitsSizes){
-        assert(self->savedBitsInfos);
-        const savedBitsInfo_t& bitsInfo=self->savedBitsInfos[blockIndex];
-        const uint32_t bits=bitsInfo.skipBitsInFirstCodeByte+bitsInfo.bitsSize;
-        if (out_skipBitsInFirstCodeByte) *out_skipBitsInFirstCodeByte=bitsInfo.skipBitsInFirstCodeByte;
-        if (out_lastByteHalfBits) *out_lastByteHalfBits=(bits&7);
-        return (bits+7)>>3;//return code border byte size
-    }
-    if (out_skipBitsInFirstCodeByte) *out_skipBitsInFirstCodeByte=0;
-    if (out_lastByteHalfBits) *out_lastByteHalfBits=0;
-    if (TNewDataSyncInfo_syncBlockIsCompressed(self,blockIndex))
-        return self->savedSizes[blockIndex];
-    else
-        return TNewDataSyncInfo_newDataBlockSize(self,blockIndex);
-}
-    
-inline static hpatch_uint64_t roll_hash_start(const adler_data_t* pdata,size_t n){
-                                              return fast_adler64_start(pdata,n); }
-hpatch_force_inline static uint64_t roll_hash_roll(uint64_t adler,size_t blockSize,
-                                                   adler_data_t out_data,adler_data_t in_data){
-                                        return fast_adler64_roll(adler,blockSize,out_data,in_data); }
-    
-#define kStrongChecksumByteSize_min    (4*8/8)
-    
-hpatch_inline static
-void toPartChecksum(unsigned char* out_partChecksum,size_t outPartBits,
-                    const unsigned char* checksum,size_t kChecksumByteSize){
-    const size_t outPartBytes=_bitsToBytes(outPartBits);
-    assert(outPartBytes<=kChecksumByteSize);
-    if (out_partChecksum!=checksum)
-        memmove(out_partChecksum,checksum,outPartBytes);
-    if (outPartBytes*8>outPartBits)
-        out_partChecksum[0]&=((1<<(outPartBits&7))-1);
-}
-
-static hpatch_inline
-size_t checkChecksumBufByteSize(size_t kStrongChecksumByteSize){
-        return kStrongChecksumByteSize*3; }
-void checkChecksumInit(unsigned char* checkChecksumBuf,size_t kStrongChecksumByteSize);
-void checkChecksumAppendData(unsigned char* checkChecksumBuf,uint32_t checksumIndex,
-                             hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum,
-                             const unsigned char* strongChecksum,const unsigned char* blockData,size_t blockDataSize);
-
-void checkChecksumEndTo(unsigned char* dst,unsigned char* checkChecksumBuf,
-                        hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum);
-    
-static hpatch_inline
-void writeRollHashBytes(uint8_t* out_part,uint64_t partRollHash,size_t savedRollHashByteSize){
-    switch (savedRollHashByteSize) {
-        case 8: *out_part++=(uint8_t)(partRollHash>>56);
-        case 7: *out_part++=(uint8_t)(partRollHash>>48);
-        case 6: *out_part++=(uint8_t)(partRollHash>>40);
-        case 5: *out_part++=(uint8_t)(partRollHash>>32);
-        case 4: *out_part++=(uint8_t)(partRollHash>>24);
-        case 3: *out_part++=(uint8_t)(partRollHash>>16);
-        case 2: *out_part++=(uint8_t)(partRollHash>> 8);
-        case 1: *out_part=(uint8_t)(partRollHash);
-            return;
-        default:
-            assert(false);
-            return;
-    }
-}
-  
-static hpatch_inline
-uint64_t readRollHashBytes(const uint8_t* part,size_t savedRollHashByteSize){
-    uint64_t partRollHash=0;
-    switch (savedRollHashByteSize) {
-        case 8: partRollHash|=((uint64_t)*part++)<<56;
-        case 7: partRollHash|=((uint64_t)*part++)<<48;
-        case 6: partRollHash|=((uint64_t)*part++)<<40;
-        case 5: partRollHash|=((uint64_t)*part++)<<32;
-        case 4: partRollHash|=((uint64_t)*part++)<<24;
-        case 3: partRollHash|=((uint64_t)*part++)<<16;
-        case 2: partRollHash|=((uint64_t)*part++)<< 8;
-        case 1: partRollHash|=((uint64_t)*part);
-            return partRollHash;
-        default:
-            assert(false);
-            return partRollHash;
-    }
-}
-
-static hpatch_force_inline
-hpatch_uint64_t toSavedPartRollHash(hpatch_uint64_t rollHash,size_t savedRollHashBits){
-    if (savedRollHashBits<64)
-        return ((rollHash>>savedRollHashBits)^rollHash) & ((((uint64_t)1)<<savedRollHashBits)-1);
-    else
-        return rollHash;
-}
-
-hpatch_inline static unsigned int upper_ilog2(uint64_t v){
-    const unsigned int _kMaxBit=sizeof(v)*8;
-    unsigned int bit=1;
-    while ((((uint64_t)1)<<bit)<v){ 
-        ++bit;
-        if (bit==_kMaxBit) break;
-    }
-    return bit;
-}
-    
-hpatch_inline static
-unsigned int getBetterCacheBlockTableBit(uint32_t blockCount){
-    const unsigned int kMinBit = 8;
-    const unsigned int kMaxBit = 23; //for limit cache memory size
-    int result=(int)upper_ilog2((1<<kMinBit)+(uint64_t)blockCount)-2;
-    result=(result<kMinBit)?kMinBit:result;
-    result=(result>kMaxBit)?kMaxBit:result;
-    return result;
-}
-
-} //namespace sync_private
-#endif //sync_client_type_private_h

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

@@ -1,252 +0,0 @@
-//  sync_diff_data.cpp
-//  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.
- */
-#include "sync_diff_data.h"
-#include <stdlib.h>
-#include <vector>
-#include <string>
-#include <stdexcept>
-#include "match_in_old.h"
-#include "../../libHDiffPatch/HPatch/patch_private.h"
-typedef unsigned char TByte;
-namespace sync_private{
-
-#define _pushV(vec,uv,stag,kTagBit) \
-    do{ TByte _buf[hpatch_kMaxPackedUIntBytes]; \
-        TByte* cur=_buf; \
-        if (!hpatch_packUIntWithTag(&cur,_buf+sizeof(_buf),uv,stag,kTagBit)) \
-            throw std::runtime_error("_packMatchedPoss() _pushV()"); \
-        vec.insert(vec.end(),_buf,cur); \
-    }while(0)
-
-static const char* kSyncDiffType="HSynd23";
-static const size_t kNeedSyncMaxRleValue=(1<<11)-1;
-
-#define _pushNeedSync(){ \
-    while (needSyncCount>0){            \
-        hpatch_StreamPos_t v=(needSyncCount<=(kNeedSyncMaxRleValue+1))? \
-                              needSyncCount:(kNeedSyncMaxRleValue+1);   \
-        _pushV(out_possBuf,v-1,0,1);    \
-        needSyncCount-=v;               \
-    } }
-
-static void _packMatchedPoss(const hpatch_StreamPos_t* newBlockDataInOldPoss,uint32_t kBlockCount,
-                             uint32_t kBlockSize,std::vector<TByte>& out_possBuf){
-    hpatch_StreamPos_t backv=0;
-    hpatch_StreamPos_t needSyncCount=0;
-    for (uint32_t i=0; i<kBlockCount; ++i) {
-        hpatch_StreamPos_t v=newBlockDataInOldPoss[i];
-        if (!isNeedSyncByOldPos(v)){
-            _pushNeedSync();
-            if (v>=backv)
-                _pushV(out_possBuf,(hpatch_StreamPos_t)(v-backv),1,1);
-            else
-                _pushV(out_possBuf,(hpatch_StreamPos_t)(backv-v)+kNeedSyncMaxRleValue,0,1);
-            backv=v+kBlockSize;
-        }else{
-            ++needSyncCount;
-        }
-    }
-    _pushNeedSync();
-}
-
-hpatch_BOOL _saveSyncDiffData(const hpatch_StreamPos_t* newBlockDataInOldPoss,uint32_t kBlockCount,uint32_t kBlockSize,
-                              hpatch_StreamPos_t oldDataSize,const TByte* newDataCheckChecksum,size_t checksumByteSize,
-                              const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,hpatch_StreamPos_t* out_diffDataPos){
-    assert(checksumByteSize==(uint32_t)checksumByteSize);
-    try {
-        std::vector<TByte> possBuf;
-        if (diffType!=kSyncDiff_data)
-            _packMatchedPoss(newBlockDataInOldPoss,kBlockCount,kBlockSize,possBuf);
-        
-        std::vector<TByte> headBuf;
-        headBuf.insert(headBuf.end(),kSyncDiffType,kSyncDiffType+strlen(kSyncDiffType)+1); //with '\0'
-        _pushV(headBuf,diffType,0,0);
-        _pushV(headBuf,kBlockCount,0,0);
-        _pushV(headBuf,kBlockSize,0,0);
-        _pushV(headBuf,oldDataSize,0,0);
-        _pushV(headBuf,checksumByteSize,0,0);
-        _pushV(headBuf,possBuf.size(),0,0);
-        hpatch_StreamPos_t curWritePos=0;
-        if (!out_diffStream->write(out_diffStream,curWritePos,&headBuf[0],
-                                   &headBuf[0]+headBuf.size())) return hpatch_FALSE;
-        curWritePos+=headBuf.size();
-        if (!out_diffStream->write(out_diffStream,curWritePos,newDataCheckChecksum,
-                                   newDataCheckChecksum+checksumByteSize)) return hpatch_FALSE;
-        curWritePos+=checksumByteSize;
-        if (!possBuf.empty()){
-            if (!out_diffStream->write(out_diffStream,curWritePos,&possBuf[0],
-                                       &possBuf[0]+possBuf.size())) return hpatch_FALSE;
-            curWritePos+=possBuf.size();
-        }
-        *out_diffDataPos=curWritePos;
-        return hpatch_TRUE;
-    } catch (...) {
-        return hpatch_FALSE;
-    }
-}
-
-
-    
-TSyncDiffData::TSyncDiffData():in_diffStream(0){
-    memset((IReadSyncDataListener*)this,0,sizeof(IReadSyncDataListener));
-    memset(&this->localPoss,0,sizeof(this->localPoss));
-}
-TSyncDiffData::~TSyncDiffData(){
-    if (this->localPoss.packedOldPoss)
-        free((void*)this->localPoss.packedOldPoss);
-}
-
-static hpatch_BOOL _TSyncDiffData_readSyncData(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){
-    TSyncDiffData* self=(TSyncDiffData*)listener->readSyncDataImport;
-    posInNeedSyncData-=isReLoadDiffHalf;
-    if (self->diffDataPos0+posInNeedSyncData+syncDataSize>self->in_diffStream->streamSize)
-        return hpatch_FALSE;
-    hpatch_BOOL result=self->in_diffStream->read(self->in_diffStream,self->diffDataPos0+posInNeedSyncData,
-                                                 out_syncDataBuf,out_syncDataBuf+syncDataSize);
-    return result;
-}
-    
-#define _loadV(dst,dstT,pclip) do{ \
-    hpatch_StreamPos_t  v;  \
-    if (!_TStreamCacheClip_unpackUIntWithTag(pclip,&v,0)) return hpatch_FALSE;  \
-    if (v!=(dstT)v) return hpatch_FALSE;    \
-    dst=(dstT)v;  }while(0)
-
-static hpatch_BOOL _loadPoss(TSyncDiffLocalPoss* self,const hpatch_TStreamInput* in_diffStream,
-                             TSyncDiffType* out_diffType,hpatch_StreamPos_t* out_diffDataPos){
-    assert(self->packedOldPoss==0);
-    size_t              packedOldPossSize;
-    TStreamCacheClip    clip;
-    TByte               _cache[hpatch_kStreamCacheSize];
-    _TStreamCacheClip_init(&clip,in_diffStream,*out_diffDataPos,in_diffStream->streamSize,
-                           _cache,hpatch_kStreamCacheSize);
-    { // type
-        char saved_type[hpatch_kMaxPluginTypeLength+1];
-        if (!_TStreamCacheClip_readType_end(&clip,'\0',saved_type)) return hpatch_FALSE;
-        if (0!=strcmp(saved_type,kSyncDiffType)) return hpatch_FALSE;//unsupport type
-        _loadV(*out_diffType,TSyncDiffType,&clip);
-        if ((*out_diffType)>_kSyncDiff_TYPE_MAX_) return hpatch_FALSE;//unsupport diff type
-    }
-    _loadV(self->kBlockCount,uint32_t,&clip);
-    _loadV(self->kBlockSize,uint32_t,&clip);
-    _loadV(self->oldDataSize,hpatch_StreamPos_t,&clip);
-    _loadV(self->checksumByteSize,uint32_t,&clip);
-    if (self->checksumByteSize>_kStrongChecksumByteSize_max_limit) return hpatch_FALSE;
-    _loadV(packedOldPossSize,size_t,&clip);
-    if (packedOldPossSize>=_TStreamCacheClip_leaveSize(&clip)) return hpatch_FALSE;
-    {  // packedOldPoss data
-        self->packedOldPoss=(TByte*)malloc(packedOldPossSize+self->checksumByteSize);
-        if (!self->packedOldPoss) return hpatch_FALSE;
-        self->packedOldPossEnd=self->packedOldPoss+packedOldPossSize;
-        if (!_TStreamCacheClip_readDataTo(&clip,(TByte*)self->savedNewDataCheckChecksum,
-                                          (TByte*)self->savedNewDataCheckChecksum+self->checksumByteSize)) return hpatch_FALSE;
-        if (!_TStreamCacheClip_readDataTo(&clip,(TByte*)self->packedOldPoss,
-                                          (TByte*)self->packedOldPossEnd)) return hpatch_FALSE;
-    }
-    *out_diffDataPos=_TStreamCacheClip_readPosOfSrcStream(&clip);
-    return hpatch_TRUE;
-}
-
-static hpatch_BOOL _syncDiffLocalPoss_nextOldPos(TSyncDiffLocalPoss* self,hpatch_StreamPos_t* out_oldPos){
-    if (self->packedNeedSyncCount>0){
-        --self->packedNeedSyncCount;
-        *out_oldPos=kBlockType_needSync;
-        return hpatch_TRUE;
-    }
-    if (self->packedOldPoss<self->packedOldPossEnd){
-        hpatch_StreamPos_t v;
-        size_t tag=(*self->packedOldPoss)>>7;
-        if (!hpatch_unpackUIntWithTag(&self->packedOldPoss,self->packedOldPossEnd,&v,1)) return hpatch_FALSE;
-        if (tag==0){
-            if (v<=kNeedSyncMaxRleValue){
-                self->packedNeedSyncCount=(uint32_t)v;
-                *out_oldPos=kBlockType_needSync;
-            }else{
-                if (self->backPos<(v-kNeedSyncMaxRleValue)) return hpatch_FALSE;
-                v=self->backPos-(v-kNeedSyncMaxRleValue);
-                *out_oldPos=v;
-                self->backPos=v+self->kBlockSize;
-            }
-        }else{ //tag==1
-            v+=self->backPos;
-            *out_oldPos=v;
-            self->backPos=v+self->kBlockSize;
-        }
-        return hpatch_TRUE;
-    }else{
-        return hpatch_FALSE;
-    }
-}
-    
-    static hpatch_inline hpatch_BOOL _syncDiffLocalPoss_isFinish(const TSyncDiffLocalPoss* self){
-        return (self->packedNeedSyncCount==0)&&(self->packedOldPoss==self->packedOldPossEnd); }
-
-hpatch_BOOL _TSyncDiffData_readOldPoss(TSyncDiffData* self,hpatch_StreamPos_t* out_newBlockDataInOldPoss,
-                                       uint32_t kBlockCount,uint32_t kBlockSize,hpatch_StreamPos_t oldDataSize,
-                                       const TByte* newDataCheckChecksum,size_t checksumByteSize){
-    TSyncDiffLocalPoss localPoss=self->localPoss;
-    //check
-    if (localPoss.kBlockCount!=kBlockCount) return hpatch_FALSE;
-    if (localPoss.kBlockSize!=kBlockSize) return hpatch_FALSE;
-    if (localPoss.kBlockSize!=kBlockSize) return hpatch_FALSE;
-    if (localPoss.oldDataSize!=oldDataSize) return hpatch_FALSE;
-    if (localPoss.checksumByteSize!=checksumByteSize) return hpatch_FALSE;
-    if (0!=memcmp(localPoss.savedNewDataCheckChecksum,newDataCheckChecksum,checksumByteSize))
-        return hpatch_FALSE;
-    if (self->diffType==kSyncDiff_data)
-        return hpatch_TRUE;
-
-    //read poss
-    for (uint32_t i=0;i<kBlockCount; ++i){
-        hpatch_StreamPos_t pos;
-        if (!_syncDiffLocalPoss_nextOldPos(&localPoss,&pos)) return hpatch_FALSE;
-        if (isNeedSyncByOldPos(pos)|(pos<oldDataSize))
-            out_newBlockDataInOldPoss[i]=pos;
-        else
-            return hpatch_FALSE;
-    }
-    return 0!=_syncDiffLocalPoss_isFinish(&localPoss);
-}
-
-hpatch_BOOL _TSyncDiffData_load(TSyncDiffData* self,const hpatch_TStreamInput* in_diffStream){
-    assert(self->readSyncDataImport==0);
-    assert(self->localPoss.packedOldPoss==0);
-    self->readSyncDataImport=self;
-    self->readSyncData=_TSyncDiffData_readSyncData;
-    self->in_diffStream=in_diffStream;
-    self->diffDataPos0=0;
-    if (!_loadPoss(&self->localPoss,in_diffStream,&self->diffType,&self->diffDataPos0))
-        return hpatch_FALSE;
-    return hpatch_TRUE;
-}
-
-} //namespace sync_private

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

@@ -1,67 +0,0 @@
-//  sync_diff_data.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_diff_data_h
-#define sync_diff_data_h
-#include "sync_client_type.h"
-namespace sync_private{
-
-hpatch_BOOL _saveSyncDiffData(const hpatch_StreamPos_t* newBlockDataInOldPoss,uint32_t kBlockCount,uint32_t kBlockSize,
-                              hpatch_StreamPos_t oldDataSize,const unsigned char* newDataCheckChecksum,size_t checksumByteSize,
-                              const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,hpatch_StreamPos_t* out_diffDataPos);
-
-
-    struct TSyncDiffLocalPoss{
-        const unsigned char*    packedOldPoss;
-        union{
-            const unsigned char*    packedOldPossEnd;
-            const unsigned char*    savedNewDataCheckChecksum;
-        };
-        hpatch_StreamPos_t      backPos;
-        hpatch_StreamPos_t      oldDataSize;
-        uint32_t                checksumByteSize;
-        uint32_t                packedNeedSyncCount;
-        uint32_t                kBlockCount;
-        uint32_t                kBlockSize;
-    };
-    
-    struct TSyncDiffData:public IReadSyncDataListener{
-        const hpatch_TStreamInput*  in_diffStream;
-        TSyncDiffLocalPoss          localPoss;
-        TSyncDiffType               diffType;
-        hpatch_StreamPos_t          diffDataPos0;
-        TSyncDiffData();
-        ~TSyncDiffData();
-    };
-    hpatch_BOOL _TSyncDiffData_load(TSyncDiffData* self,const hpatch_TStreamInput* in_diffStream);
-    hpatch_BOOL _TSyncDiffData_readOldPoss(TSyncDiffData* self,hpatch_StreamPos_t* out_newBlockDataInOldPoss,
-                                           uint32_t kBlockCount,uint32_t kBlockSize,hpatch_StreamPos_t oldDataSize,
-                                           const unsigned char* newDataCheckChecksum,size_t checksumByteSize);
-
-}
-#endif // sync_diff_data_h