react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/zsync_client_wrapper/zsync_info_client.cpp

@@ -1,351 +0,0 @@
-//  zsync_info_client.cpp
-//  zsync_client for hsynz
-//  Created by housisong on 2025-06-28.
-/*
- The MIT License (MIT)
- Copyright (c) 2025 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 "zsync_info_client.h"
-#include "zsync_client_type_private.h"
-#include "../../file_for_patch.h"
-#include "../../libHDiffPatch/HPatch/patch_private.h"
-#include "../../_atosize.h"
-#include "../../_hextobytes.h"
-#include <stdio.h> //sscanf
-
-namespace sync_private{
-#ifdef  check
-# undef check
-#endif
-#define check(v,errorCode) \
-            do{ if (!(v)) { if (result==kSyncClient_ok) result=errorCode; \
-                            if (!_inClear) goto clear; } }while(0)
-
-static const char* kZsync_VERSION="0.6.3"; //now supported zsync version
-
-} //namespace sync_private
-using namespace sync_private;
-
-static char* _readZsyncStr(TStreamCacheClip* newSyncInfo_clip,char* out_str,size_t strBufLen){
-    if (!_TStreamCacheClip_readStr_end(newSyncInfo_clip,'\n',out_str,strBufLen))
-        return 0; //error
-    int strLen=(int)strlen(out_str);
-    if (strLen==0) return out_str; //key-value empty, end loop
-    while (strLen>0){
-        char& c=out_str[--strLen];
-        if ((c=='\r')||(c=='\n')||(c==' ')) c=0;//remove end '\r' '\n' ' '
-        else break;
-    }
-    char* pv = strchr(out_str,':');
-    if (pv==0) return 0; //error
-    *pv++=0; //split key and value
-    if (*pv==' ') ++pv; //remove value begin ' '
-    return pv;
-}
-
-static const size_t kMaxZsyncStrLine=1024;
-static
-TSyncClient_resultType _checkNewZsyncInfoType(TStreamCacheClip* newSyncInfo_clip){
-    char  key[kMaxZsyncStrLine];
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    const char* value=_readZsyncStr(newSyncInfo_clip,key,sizeof(key));
-    check(value!=0,kSyncClient_newZsyncInfoTypeError);
-    check(0==strcmp(key,"zsync"),kSyncClient_newZsyncInfoTypeError);
-    check(0!=strcmp(value,"0.0.4"),kSyncClient_newZsyncInfoTypeError);//not compatible with zsync 0.0.4
-clear:
-    _inClear=1;
-    return result;
-}
-
-TSyncClient_resultType checkNewZsyncInfoType(const hpatch_TStreamInput* newSyncInfo){
-    TStreamCacheClip    clip;
-    TByte temp_cache[hpatch_kStreamCacheSize];
-    static_assert(hpatch_kStreamCacheSize>=kMaxZsyncStrLine,"hpatch_kStreamCacheSize must be >= kMaxZsyncStrLine");
-    _TStreamCacheClip_init(&clip,newSyncInfo,0,newSyncInfo->streamSize,temp_cache,sizeof(temp_cache));
-    return _checkNewZsyncInfoType(&clip);
-}
-
-TSyncClient_resultType checkNewZsyncInfoType_by_file(const char* newSyncInfoFile){
-    hpatch_TFileStreamInput  newSyncInfo;
-    hpatch_TFileStreamInput_init(&newSyncInfo);
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    check(hpatch_TFileStreamInput_open(&newSyncInfo,newSyncInfoFile), kSyncClient_newZsyncInfoOpenError);
-    result=checkNewZsyncInfoType(&newSyncInfo.base);
-clear:
-    _inClear=1;
-    check(hpatch_TFileStreamInput_close(&newSyncInfo), kSyncClient_newZsyncInfoCloseError);
-    return result;
-}
-
-
-static bool read2PartHashTo(TStreamCacheClip* clip,TByte* rollHashs,size_t rollBytes,
-                            TByte* checksums,size_t checksumBytes,uint32_t kBlockCount){
-    for (size_t i=0; i<kBlockCount; ++i,rollHashs+=rollBytes,checksums+=checksumBytes){
-        if (!_TStreamCacheClip_readDataTo(clip,rollHashs,rollHashs+rollBytes)) return false;
-        if (!_TStreamCacheClip_readDataTo(clip,checksums,checksums+checksumBytes)) return false;
-    }
-    return true;
-}
-
-
-    #define _DEF_insertOutBits(){ \
-            if ((insert>=kBlockCount)||(curBits==0)||(curBits>=(1<<(32-3)))) return false;  \
-            if (insert==0) self->newSyncDataOffsert=curBlockBitsPos>>3;                     \
-            savedBitsInfos[insert].skipBitsInFirstCodeByte=curBlockBitsPos&((1<<3)-1);      \
-            savedBitsInfos[insert].bitsSize=(uint32_t)curBits;  \
-            insert++;   \
-            curBlockBitsPos+=curBits;   \
-            curOuts=0;  \
-            curBits=0; }
-
-static bool readSavedBitsTo(const TByte* zmap2_data,size_t zmap2_blocks,TNewDataZsyncInfo* self){
-    size_t kBlockSize=self->kSyncBlockSize;
-    size_t kBlockCount=(size_t)TNewDataSyncInfo_blockCount(self);
-    hpatch_StreamPos_t sumOuts=0;
-    hpatch_StreamPos_t curBlockBitsPos=0;
-    savedBitsInfo_t* savedBitsInfos=self->savedBitsInfos;
-    size_t insert=0,curOuts=0,curBits=0;
-    for (size_t i=0;i<zmap2_blocks;++i,zmap2_data+=4){
-        const uint16_t bits=(((uint16_t)zmap2_data[0])<<8)|zmap2_data[1];
-        uint16_t       outs=(((uint16_t)zmap2_data[2])<<8)|zmap2_data[3];
-        const bool isBolckStart=((outs>>15)==0);
-        outs&=((1<<15)-1);
-        sumOuts+=outs;
-        if (outs==0){
-            if (((insert==0)&&(curOuts==0))||(insert>=kBlockCount)){ assert(isBolckStart); curBlockBitsPos+=bits; continue; }
-        }
-        if (curOuts+outs>kBlockSize){
-            if (curOuts!=kBlockSize) return false;
-            _DEF_insertOutBits();
-        }
-        curOuts+=outs;
-        curBits+=bits;
-    }
-    if (curOuts>0){
-        if (curOuts>kBlockSize) return false;
-        _DEF_insertOutBits();
-    }
-    self->newSyncDataSize=((curBlockBitsPos+7)>>3)+8; //8 is gzip file foot size
-    return (sumOuts==self->newDataSize)&&(insert==kBlockCount)&&(curOuts==0)&&(curBits==0);
-}
-
-static TSyncClient_resultType
-    _TNewDataZsyncInfo_open(TNewDataZsyncInfo* self,const hpatch_TStreamInput* newSyncInfo,hpatch_BOOL isIgnoreCompressInfo,
-                            ISyncInfoListener *listener){
-    assert((self->_import==0)&&(self->_extraMem==0));
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    size_t checksumBytes=20;
-    hpatch_byte _savedNewDataCheckChecksum[20];
-    const char* checksumType="";
-    TStreamCacheClip    clip;
-    hpatch_uint32_t     kBlockCount=0;
-    TByte* temp_cache=0;
-    TByte* zmap2_data=0;
-    size_t zmap2_blocks;
-    const char*  zmap2_data_compressType="gzipD";
-    const size_t zmap2_data_compressDictSize=32*1024;
-    const size_t kFileIOBufBetterSize=hpatch_kFileIOBufBetterSize;
-
-    self->strongChecksumPlugin=listener->findChecksumPlugin(listener,"md4"); //for oldData
-    check(self->strongChecksumPlugin!=0,kSyncClient_noStrongChecksumPluginError);
-    self->isNotCChecksumNewMTParallel=hpatch_TRUE; //unsupport parallel checksum (when _matchRange), must check by order (when _writeToNewOrDiff_by)
-
-    temp_cache=(TByte*)malloc(kFileIOBufBetterSize);
-    check(temp_cache!=0,kSyncClient_memError);
-    _TStreamCacheClip_init(&clip,newSyncInfo,0,newSyncInfo->streamSize,
-                            temp_cache,kFileIOBufBetterSize);
-
-    self->fileChecksumPlugin=0;
-    self->isSeqMatch=hpatch_FALSE;
-    self->savedStrongChecksumByteSize=16;//for md4
-    self->savedRollHashByteSize=4; //for adler32
-
-
-    result=_checkNewZsyncInfoType(&clip); //check type
-    check(result==kSyncClient_ok,result);
-    while (1){
-        char  key[kMaxZsyncStrLine];
-        const char* value=_readZsyncStr(&clip,key,sizeof(key));
-        check(value!=0,kSyncClient_newZsyncInfoDataError);
-        if (value==key){ assert(strlen(key)==0); break; }//end of key-value
-
-        if (0==strcmp(key,"Min-Version")){
-            check(strcmp(value,kZsync_VERSION)<=0,kSyncClient_newZsyncInfoMinVersionError);
-        }else if (0==strcmp(key,"Length")){
-            check(a_to_u64(value,strlen(value),&self->newDataSize),kSyncClient_newZsyncInfoDataError);
-        }else if (0==strcmp(key,"Blocksize")){
-            hpatch_uint64_t blockSize;
-            check(a_to_u64(value,strlen(value),&blockSize)
-                    &&(blockSize==(hpatch_uint32_t)blockSize)
-                    &&(blockSize>0)&&(0==(blockSize&(blockSize-1))),kSyncClient_newZsyncInfoBlockSizeError);
-            self->kSyncBlockSize=(hpatch_uint32_t)blockSize;
-        }else if (0==strcmp(key,"Hash-Lengths")){
-            int sequentialMatch,savedRollHashBytes,savedStrongChecksumBytes;
-            check((sscanf(value,"%d,%d,%d",&sequentialMatch,&savedRollHashBytes,&savedStrongChecksumBytes)==3)
-                    &&(sequentialMatch>=1)&&(sequentialMatch<=2)
-                    &&(savedRollHashBytes>=1)&&(savedRollHashBytes<=4)
-                    &&(savedStrongChecksumBytes>=3)&&(savedStrongChecksumBytes<=16),kSyncClient_newZsyncInfoDataError);
-            self->savedStrongChecksumByteSize=savedStrongChecksumBytes;
-            self->savedStrongChecksumBits=savedStrongChecksumBytes*8;
-            self->savedRollHashByteSize=savedRollHashBytes;
-            self->savedRollHashBits=savedRollHashBytes*8;
-            self->isSeqMatch=(sequentialMatch>1)?hpatch_TRUE:hpatch_FALSE;
-        }else if (0==strcmp(key,"Z-Map2")){
-            hpatch_uint64_t _zmBlocks;
-            const size_t _kZmOneSize=4;
-            check(a_to_u64(value,strlen(value),&_zmBlocks)
-                    &&(_zmBlocks==(((size_t)(_zmBlocks*_kZmOneSize))/_kZmOneSize)),kSyncClient_newZsyncInfoZmap2BlocksError);
-            zmap2_blocks=(size_t)_zmBlocks;
-            if (!isIgnoreCompressInfo){
-                zmap2_data=(TByte*)malloc(zmap2_blocks*_kZmOneSize);
-                check(zmap2_data!=0,kSyncClient_memError);
-                check(_TStreamCacheClip_readDataTo(&clip,zmap2_data,zmap2_data+zmap2_blocks*_kZmOneSize), kSyncClient_newZsyncInfoDataError);
-            }else{
-                check(_TStreamCacheClip_skipData(&clip,zmap2_blocks*_kZmOneSize), kSyncClient_newZsyncInfoDataError);
-                zmap2_blocks=0;
-            }
-        }else if (0==strcmp(key,"SHA-1")){
-            self->fileChecksumPlugin=listener->findChecksumPlugin(listener,"sha1"); //for newData
-            check(self->fileChecksumPlugin!=0,kSyncClient_noStrongChecksumPluginError);
-            check(checksumBytes==self->fileChecksumPlugin->checksumByteSize(),kSyncClient_noStrongChecksumPluginError);
-            checksumType=self->fileChecksumPlugin->checksumType();
-            check(strlen(value)==checksumBytes*2,kSyncClient_newZsyncInfoDataError);
-            check(hexs_to_bytes(value,checksumBytes*2,_savedNewDataCheckChecksum),kSyncClient_newZsyncInfoDataError);
-        }else{ //ignore key-value
-            continue;
-        }
-    }
-    check((self->newDataSize>0)&&(self->kSyncBlockSize>0),kSyncClient_newZsyncInfoDataError);
-    {
-        hpatch_StreamPos_t v=TNewDataSyncInfo_blockCount(self);
-        kBlockCount=(uint32_t)v;
-        check((kBlockCount==v),kSyncClient_newZsyncInfoBlockSizeTooSmallError);//unsupport too large kBlockCount, need rise BlockSize when make
-        if (zmap2_data)
-            check((kBlockCount<=zmap2_blocks),kSyncClient_newZsyncInfoZmap2BlocksSmallError);
-    }
-    hpatch_StreamPos_t savedHashDataSize;
-    {
-        savedHashDataSize=(self->savedRollHashByteSize+self->savedStrongChecksumByteSize)*(hpatch_StreamPos_t)kBlockCount;
-        self->newSyncInfoSize=_TStreamCacheClip_readPosOfSrcStream(&clip)+savedHashDataSize;
-        check(newSyncInfo->streamSize>=self->newSyncInfoSize,kSyncClient_newSyncInfoDataError);
-    }
-    hpatch_StreamPos_t memSize;
-    {
-        TByte* curMem=0;
-        memSize=sizeof(hpatch_StreamPos_t)*3+z_checkChecksumBufByteSize(checksumBytes);
-        memSize+=strlen(checksumType)+1; //checksumType
-        memSize+=savedHashDataSize+self->savedRollHashByteSize; //adding 1 empty rollHash for isSeqMatch
-        if (zmap2_data)
-            memSize +=strlen(zmap2_data_compressType)+1; //compressType
-
-        check(memSize==(size_t)memSize,kSyncClient_memError);
-        curMem=(TByte*)malloc((size_t)memSize);
-        check(curMem!=0,kSyncClient_memError);
-        self->_import=curMem;
-        
-        self->strongChecksumType=(const char*)curMem;
-        curMem+=strlen(checksumType)+1;
-        memcpy((TByte*)self->strongChecksumType,checksumType,curMem-(TByte*)self->strongChecksumType);
-        {
-            curMem=(TByte*)_hpatch_align_upper(curMem,sizeof(hpatch_StreamPos_t));
-            self->savedNewDataCheckChecksum=(unsigned char*)curMem;
-            curMem+=z_checkChecksumBufByteSize(checksumBytes);
-            if (self->fileChecksumPlugin)
-                memcpy(self->savedNewDataCheckChecksum,_savedNewDataCheckChecksum,checksumBytes);
-            else
-                memset(self->savedNewDataCheckChecksum,0,checksumBytes);//be zero for null checksum
-        }
-        
-        if (zmap2_data){
-            self->compressType=(char*)curMem;
-            curMem+=strlen(zmap2_data_compressType)+1;
-            memcpy((char*)self->compressType,zmap2_data_compressType,strlen(zmap2_data_compressType)+1);
-            self->dictSize=zmap2_data_compressDictSize;
-        }
-
-        curMem=(TByte*)_hpatch_align_upper(curMem,sizeof(hpatch_StreamPos_t));
-        self->rollHashs=curMem;
-        curMem+=self->savedRollHashByteSize*((size_t)kBlockCount+1);//adding 1 empty rollHash for isSeqMatch
-        memset(curMem-self->savedRollHashByteSize,0,self->savedRollHashByteSize); //a empty rollHash
-        curMem=(TByte*)_hpatch_align_upper(curMem,sizeof(hpatch_StreamPos_t));
-        self->partChecksums=curMem;
-        curMem+=self->savedStrongChecksumByteSize*(size_t)kBlockCount;
-        assert(curMem<=(TByte*)self->_import+memSize);
-    }
-
-    if (zmap2_data){//zmap2 compressed bit size
-        self->_decompressPlugin=listener->findDecompressPlugin(listener,self->compressType,self->dictSize);
-        check(self->_decompressPlugin!=0,kSyncClient_noDecompressPluginError);
-        self->savedBitsInfos=(savedBitsInfo_t*)zmap2_data; //used same mem buf and safe
-        self->_extraMem=zmap2_data; //free mem by close
-        zmap2_data=0;
-        check(readSavedBitsTo((const TByte*)self->_extraMem,zmap2_blocks,self), //zmap2_data convert to savedBitsInfos
-            kSyncClient_newZsyncInfoZMap2DataError);
-        self->isSavedBitsSizes=hpatch_TRUE;
-    }
-
-    //rollHashs & partStrongChecksums
-    check(read2PartHashTo(&clip, self->rollHashs,self->savedRollHashByteSize,
-                          self->partChecksums,self->savedStrongChecksumByteSize,
-                          kBlockCount), kSyncClient_newZsyncInfoDataError);
-
-clear:
-    _inClear=1;
-    if (result!=kSyncClient_ok) TNewDataZsyncInfo_close(self);
-    if (zmap2_data) free(zmap2_data);
-    if (temp_cache) free(temp_cache);
-    return result;
-}
-
-void TNewDataZsyncInfo_close(TNewDataZsyncInfo* self){
-    TNewDataSyncInfo_close(self);
-}
-
-TSyncClient_resultType TNewDataZsyncInfo_open(TNewDataZsyncInfo* self,const hpatch_TStreamInput* newSyncInfo,hpatch_BOOL isIgnoreCompressInfo,
-                                              ISyncInfoListener* listener){
-    TSyncClient_resultType result=_TNewDataZsyncInfo_open(self,newSyncInfo,isIgnoreCompressInfo,listener);
-    if ((result==kSyncClient_ok)&&listener->onLoadedNewSyncInfo)
-        listener->onLoadedNewSyncInfo(listener,self);
-    return result;
-}
-
-TSyncClient_resultType TNewDataZsyncInfo_open_by_file(TNewDataZsyncInfo* self,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
-                                                      ISyncInfoListener *listener){
-    hpatch_TFileStreamInput  newSyncInfo;
-    hpatch_TFileStreamInput_init(&newSyncInfo);
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    check(hpatch_TFileStreamInput_open(&newSyncInfo,newSyncInfoFile), kSyncClient_newZsyncInfoOpenError);
-    result=_TNewDataZsyncInfo_open(self,&newSyncInfo.base,isIgnoreCompressInfo,listener);
-clear:
-    _inClear=1;
-    check(hpatch_TFileStreamInput_close(&newSyncInfo), kSyncClient_newZsyncInfoCloseError);
-    if ((result==kSyncClient_ok)&&listener->onLoadedNewSyncInfo)
-        listener->onLoadedNewSyncInfo(listener,self);
-    return result;
-}
-

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/zsync_client_wrapper/zsync_info_client.h

@@ -1,42 +0,0 @@
-//  zsync_info_client.h
-//  zsync_client for hsynz
-//  Created by housisong on 2025-06-28.
-/*
- The MIT License (MIT)
- Copyright (c) 2025 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 zsync_info_client_h
-#define zsync_info_client_h
-#include "zsync_client_type.h"
-
-TSyncClient_resultType TNewDataZsyncInfo_open_by_file(TNewDataZsyncInfo* self,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
-                                                      ISyncInfoListener* listener);
-TSyncClient_resultType TNewDataZsyncInfo_open(TNewDataZsyncInfo* self,const hpatch_TStreamInput* newSyncInfo,hpatch_BOOL isIgnoreCompressInfo,
-                                              ISyncInfoListener* listener);
-void TNewDataZsyncInfo_close(TNewDataZsyncInfo* self);
-
-TSyncClient_resultType  checkNewZsyncInfoType_by_file(const char* newSyncInfoFile);
-TSyncClient_resultType  checkNewZsyncInfoType(const hpatch_TStreamInput* newSyncInfo);
-
-#endif // zsync_info_client_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/zsync_client_wrapper/zsync_match_in_old.cpp

@@ -1,124 +0,0 @@
-//  zsync_match_in_old.cpp
-//  zsync_client
-/*
- The MIT License (MIT)
- Copyright (c) 2025 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 "zsync_match_in_old.h"
-#include "zsync_client_type_private.h"
-#include "../sync_client/sync_client_private.h"
-#include "../sync_client/match_in_types.h"
-namespace sync_private{
-
-template<bool isSeqMatch>
-struct TStreamDataRoll_z:public TStreamDataCache_base{
-    inline TStreamDataRoll_z(const hpatch_TStreamInput* baseStream,hpatch_StreamPos_t streamRollBegin,
-                             hpatch_StreamPos_t streamRollEnd,uint32_t kSyncBlockSize,
-                             hpatch_TChecksum* strongChecksumPlugin,void* _readLocker=0)
-        :TStreamDataCache_base(baseStream,streamRollBegin,streamRollEnd,
-                               (isSeqMatch?kSyncBlockSize:0),kSyncBlockSize-1+(isSeqMatch?kSyncBlockSize:0),
-                               kSyncBlockSize,strongChecksumPlugin,_readLocker){
-            if (isRollEnded()) return;
-            _startCurHash();
-        }
-    hpatch_force_inline tm_roll_uint hashValue()const{
-        if (isSeqMatch)
-            return (((tm_roll_uint)m_rollHash)<<(sizeof(uint32_t)*8)) | m_rollHashNext;
-        else
-            return m_rollHash; }
-    hpatch_force_inline bool roll(){
-        const TByte* curIn=m_cur+m_kSyncBlockSize;
-        assert(curIn>=m_cache.data());
-        if (curIn+(isSeqMatch?m_kSyncBlockSize:0)<m_cache.data_end()){
-            m_rollHash=z_roll_hash32_roll(m_rollHash,m_kSyncBlockSize,*m_cur,*curIn);
-            if (isSeqMatch)
-                m_rollHashNext=z_roll_hash32_roll(m_rollHashNext,m_kSyncBlockSize,m_cur[m_kSyncBlockSize],curIn[m_kSyncBlockSize]);
-            ++m_cur;
-            return true;
-        }else{
-            return _cacheAndRoll();
-        }
-    }
-    bool nextBlock(){
-        m_cur+=m_kSyncBlockSize;
-        if (m_cur+m_kSyncBlockSize+(isSeqMatch?m_kSyncBlockSize:0)>m_cache.data_end()){
-            TStreamDataCache_base::_cache();
-            if (isRollEnded()) return false;
-        }
-        _startCurHash();
-        return true;
-    }
-protected:
-    uint32_t    m_rollHash;
-    uint32_t    m_rollHashNext;
-
-    void _startCurHash(){
-        m_rollHash=z_roll_hash32_start(m_cur,m_kSyncBlockSize);
-        if (isSeqMatch)
-            m_rollHashNext=z_roll_hash32_start(m_cur+m_kSyncBlockSize,m_kSyncBlockSize);   
-    }
-    bool _cacheAndRoll(){
-        TStreamDataCache_base::_cache();
-        if (isRollEnded()) return false;
-        return roll();
-    }
-};
-
-static hpatch_force_inline
-uint64_t z_seq_toSavedPartRollHash(uint64_t rollHash,size_t savedRollHashBits){
-    return (z_toSavedPartRollHash(rollHash>>32,savedRollHashBits)<<savedRollHashBits)
-          |z_toSavedPartRollHash(rollHash,savedRollHashBits);
-}
-
-static void _z_rollMatch(_TMatchDatas& rd,hpatch_StreamPos_t oldRollBegin,hpatch_StreamPos_t oldRollEnd,void* _mt){
-    const TNewDataSyncInfo* newSyncInfo=rd.newSyncInfo;
-    if (newSyncInfo->isSeqMatch){
-        _tm_rollMatch<TStreamDataRoll_z<true>,TBloomFilter<uint64_t>,true>(rd,oldRollBegin,oldRollEnd,
-                z_seq_toSavedPartRollHash, _mt);
-    }else{
-        _tm_rollMatch<TStreamDataRoll_z<false>,TBloomFilter<uint64_t>,false>(rd,oldRollBegin,oldRollEnd,
-                z_toSavedPartRollHash, _mt);
-    }
-}
-
-static const uint32_t* _z_getSortedIndexs(TAutoMem& _mem_sorted,const TNewDataSyncInfo* newSyncInfo,void* filter){
-    return _tm_getSortedIndexs(_mem_sorted,newSyncInfo,*(TBloomFilter<uint64_t>*)filter);
-}
-
-void z_matchNewDataInOld(hpatch_StreamPos_t* out_newBlockDataInOldPoss,const TNewDataSyncInfo* newSyncInfo,
-                         const hpatch_TStreamInput* oldStream,int threadNum){
-    TBloomFilter<uint64_t> filter64;
-    filter64.init((size_t)(TNewDataSyncInfo_blockCount(newSyncInfo)-newSyncInfo->samePairCount));
-
-    _TMatchDatas matchDatas; memset(&matchDatas,0,sizeof(matchDatas));
-    matchDatas.filter=&filter64;
-    matchDatas.out_newBlockDataInOldPoss=out_newBlockDataInOldPoss;
-    matchDatas.newSyncInfo=newSyncInfo;
-    matchDatas.oldStream=oldStream;
-    matchDatas.rollMatch=_z_rollMatch;
-    matchDatas.getSortedIndexs=_z_getSortedIndexs;
-    _matchNewDataInOld(matchDatas,threadNum);
-}
-
-} //namespace sync_private

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/zsync_client_wrapper/zsync_match_in_old.h

@@ -1,38 +0,0 @@
-//  zsync_match_in_old.h
-//  zsync_client for hsynz
-/*
- The MIT License (MIT)
- Copyright (c) 2025 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 zsync_match_in_old_h
-#define zsync_match_in_old_h
-#include "zsync_client_type.h"
-#include "../sync_client/match_in_old.h"
-namespace sync_private{
-
-void z_matchNewDataInOld(hpatch_StreamPos_t* out_newBlockDataInOldPoss,const TNewDataSyncInfo* newSyncInfo,
-                         const hpatch_TStreamInput* oldStream,int threadNum);
-
-} //namespace sync_private
-#endif // zsync_match_in_old_h