react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_make/sync_make_hash_clash.h

@@ -1,122 +0,0 @@
-//  sync_make_hash_clash.h
-//  sync_make
-//  Created by housisong on 2019-09-17.
-/*
- The MIT License (MIT)
- Copyright (c) 2019-2022 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 hsync_make_hash_clash_h
-#define hsync_make_hash_clash_h
-#include "../sync_client/sync_client_type.h"
-#include "../sync_client/sync_client_type_private.h"
-
-namespace sync_private{
-    const size_t _kMaxRollHashBits      = 8*sizeof(uint64_t);
-    const size_t _kBadRollHashBits      = _kMaxRollHashBits/2; //for reduce defect in fadler64 & toSavedPartRollHash
-    
-    hpatch_inline static
-    size_t _estimateCompareCountBit(hpatch_StreamPos_t newDataSize,uint32_t kSyncBlockSize){
-        hpatch_StreamPos_t blockCount=getSyncBlockCount(newDataSize,kSyncBlockSize);
-        const hpatch_StreamPos_t nbmul=newDataSize*blockCount;
-        if ((blockCount==0)||(nbmul/blockCount)==newDataSize)
-            return sync_private::upper_ilog2(nbmul);
-        else
-            return sync_private::upper_ilog2(newDataSize)+sync_private::upper_ilog2(blockCount);
-    }
-    
-    hpatch_inline static
-    size_t getNeedHashBits(size_t kSafeHashClashBit,hpatch_StreamPos_t newDataSize,uint32_t kSyncBlockSize){
-        const size_t _kNeedMinHashBits=_kNeedMinRollHashBits+_kNeedMinStrongHashBits;
-        size_t compareCountBit=_estimateCompareCountBit(newDataSize,kSyncBlockSize);
-        size_t result=compareCountBit+kSafeHashClashBit;
-        return (result>=_kNeedMinHashBits)?result:_kNeedMinHashBits;
-    }
-    hpatch_inline static
-    size_t getSavedHashBits(size_t kSafeHashClashBit,hpatch_StreamPos_t newDataSize,uint32_t kSyncBlockSize,
-                            size_t kStrongHashBits,size_t* out_partRollHashBits,size_t* out_partStrongHashBits){
-        const size_t result=getNeedHashBits(kSafeHashClashBit,newDataSize,kSyncBlockSize);
-        assert(kStrongHashBits>=kStrongChecksumByteSize_min*8);
-        assert(result<=kStrongHashBits+_kMaxRollHashBits);
-        size_t compareCountBit=_estimateCompareCountBit(newDataSize,kSyncBlockSize);
-        size_t rollHashBits=compareCountBit;
-        if (rollHashBits<_kNeedMinRollHashBits) rollHashBits=_kNeedMinRollHashBits;
-        else if (rollHashBits>_kMaxRollHashBits) rollHashBits=_kMaxRollHashBits;
-        assert(rollHashBits<=result);
-
-        #define __StrongHashBITS_ ((size_t)(result-rollHashBits))
-        if (__StrongHashBITS_<rollHashBits){
-            rollHashBits-=2;
-        }
-        if (__StrongHashBITS_<_kNeedMinStrongHashBits){
-            rollHashBits=result-_kNeedMinStrongHashBits;
-        }
-        if (rollHashBits<__StrongHashBITS_){
-            size_t moveBits=(__StrongHashBITS_-rollHashBits+2)/3;
-            moveBits=(moveBits<=_kNeedMinRollHashBits)?moveBits:_kNeedMinRollHashBits;
-            rollHashBits+=moveBits;
-            if (rollHashBits>_kMaxRollHashBits) rollHashBits=_kMaxRollHashBits;
-        }
-        if (__StrongHashBITS_>kStrongHashBits){
-            rollHashBits=result-kStrongHashBits;
-            assert((rollHashBits>=_kNeedMinRollHashBits)&&(rollHashBits<=_kMaxRollHashBits));
-        }
-        if (rollHashBits==_kBadRollHashBits){
-            size_t moveBits=(__StrongHashBITS_<kStrongHashBits)?1:((size_t)0)-((size_t)1);
-            rollHashBits-=moveBits;
-        }
-        *out_partRollHashBits=rollHashBits;
-        *out_partStrongHashBits=__StrongHashBITS_;
-        #undef __StrongHashBITS_
-        return result;
-    }
-}//namespace sync_private
-
-
-hpatch_inline static //check strongChecksumBits is strong enough?
-bool _getStrongForHashClash(size_t kSafeHashClashBit,hpatch_StreamPos_t newDataSize,
-                            uint32_t kSyncBlockSize,size_t strongChecksumBits,size_t validRollHashBits){
-    if (strongChecksumBits<kStrongChecksumByteSize_min*8)
-        return false;
-    size_t needHashBits=sync_private::getNeedHashBits(kSafeHashClashBit,newDataSize,kSyncBlockSize);
-    return validRollHashBits+strongChecksumBits>=needHashBits;
-}
-
-hpatch_inline static //check strongChecksumBits is strong enough?
-bool getStrongForHashClash(size_t kSafeHashClashBit,hpatch_StreamPos_t newDataSize,
-                           uint32_t kSyncBlockSize,size_t strongChecksumBits){
-    return _getStrongForHashClash(kSafeHashClashBit,newDataSize,kSyncBlockSize,
-                                  strongChecksumBits,sync_private::_kMaxRollHashBits);
-}
-
-hpatch_inline static
-hpatch_StreamPos_t estimatePatchMemSize(size_t kSafeHashClashBit,hpatch_StreamPos_t newDataSize,
-                                        uint32_t kSyncBlockSize,bool isUsedCompress){
-    hpatch_StreamPos_t blockCount=getSyncBlockCount(newDataSize,kSyncBlockSize);
-    hpatch_StreamPos_t bet=24;
-    bet+= _bitsToBytes(sync_private::getNeedHashBits(kSafeHashClashBit,newDataSize,kSyncBlockSize)+4);
-    bet+=isUsedCompress?4:0;
-    return bet*blockCount + 2*(hpatch_StreamPos_t)kSyncBlockSize;
-}
-
-#endif // hsync_make_hash_clash_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_make/sync_make_private.h

@@ -1,66 +0,0 @@
-//  sync_make_private.h
-//  sync_make
-/*
- The MIT License (MIT)
- Copyright (c) 2019-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 hsync_make_private_h
-#define hsync_make_private_h
-#include "../../libHDiffPatch/HPatch/checksum_plugin.h"
-#include "../../libHDiffPatch/HDiff/diff_types.h"
-#include "../../dirDiffPatch/dir_diff/dir_diff_tools.h"
-#include "../sync_client/sync_client_type.h"
-#include "../sync_client/match_in_types.h"
-#include "dict_compress_plugin.h"
-#include "hsynz_plugin.h"
-namespace sync_private{
-
-struct _TCompress;
-struct _TCreateDatas;
-struct TWorkBuf;
-
-struct _ICreateSync_by{
-    tm_roll_uint     (*roll_hash_start)(const adler_data_t* pdata,size_t n);
-    tm_roll_uint (*toSavedPartRollHash)(tm_roll_uint rollHash,size_t savedRollHashBits);
-    void           (*checkChecksumInit)(unsigned char* checkChecksumBuf,size_t checksumByteSize);
-    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);
-    void          (*checkChecksumEndTo)(unsigned char* dst,unsigned char* checkChecksumBuf,
-                                        hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum);
-    void       (*create_sync_data_part)(_TCreateDatas& cd,TWorkBuf* workData,
-                                        hdiff_private::CChecksum& checksumBlockData,_TCompress& compress,void* _mt);
-    
-};
-
-void _create_sync_data_by(_ICreateSync_by* cs_by,TNewDataSyncInfo* newSyncInfo,
-                          const hpatch_TStreamInput* newData,const hpatch_TStreamOutput* out_hsynz,
-                          hsync_TDictCompress* compressPlugin,hsync_THsynz* hsynzPlugin,size_t threadNum);
-
-void _private_create_sync_data(TNewDataSyncInfo* newSyncInfo, const hpatch_TStreamInput*  newData,
-                               const hpatch_TStreamOutput* out_hsyni, const hpatch_TStreamOutput* out_hsynz,
-                               hsync_TDictCompress* compressPlugin, hsync_THsynz* hsynzPlugin,size_t threadNum);
-               
-}
-#endif // hsync_make_private_h

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

@@ -1,36 +0,0 @@
-// zsync_client_type.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_client_type_h
-#define zsync_client_type_h
-#include "../sync_client/sync_info_client.h"
-
-typedef TNewDataSyncInfo TNewDataZsyncInfo;
-static inline
-void TNewDataZsyncInfo_init(TNewDataZsyncInfo* self) { TNewDataSyncInfo_init(self); }
-
-#endif

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

@@ -1,81 +0,0 @@
-//  zsync_client_type_private.h
-//  zsync_client for hsynz
-//  Created by housisong on 2025-07-04.
-/*
- The MIT License (MIT)
- Copyright (c) 2015 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_client_type_private_h
-#define zsync_client_type_private_h
-#include "../sync_client/sync_client_type_private.h"
-
-namespace sync_private{
-
-inline static hpatch_uint32_t z_roll_hash32_start(const adler_data_t* pdata,size_t n){
-    hpatch_uint32_t radler=0; hpatch_uint32_t sum=0;
-    for (;n>0;n--){
-        radler+=*pdata++;
-        sum+=radler;
-    }
-    return (sum<<16) | (radler&0xFFFF);
-}
-    
-hpatch_force_inline static hpatch_uint32_t z_roll_hash32_roll(hpatch_uint32_t adler,size_t blockSize,
-                                                              adler_data_t out_data,adler_data_t in_data){
-    hpatch_uint32_t sum=(adler>>16)-((hpatch_uint32_t)blockSize)*out_data;
-    hpatch_uint32_t radler=adler+in_data-out_data;
-    return ((sum+radler)<<16) | (radler&0xFFFF);
-}
-
-
-struct zsync_checkChecksum_t{
-    volatile hpatch_uint32_t checkBlockIndex;
-    volatile hpatch_byte     state; //0: not run, 1: checking, 2: end
-};
-
-static hpatch_inline
-size_t z_checkChecksumBufByteSize(size_t kStrongChecksumByteSize){
-        return 2*kStrongChecksumByteSize+sizeof(zsync_checkChecksum_t); }
-
-void z_checkChecksumInit(unsigned char* checkChecksumBuf,size_t kStrongChecksumByteSize);
-
-
-//must call by checksumIndex order
-void z_checkChecksumAppendData(unsigned char* checkChecksumBuf,uint32_t checksumIndex,
-                               hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum,
-                               const unsigned char* blockChecksum,const unsigned char* blockData,size_t blockDataSize);
-
-void z_checkChecksumEndTo(unsigned char* dst,unsigned char* checkChecksumBuf,
-                          hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum);
-
-static hpatch_force_inline
-hpatch_uint64_t z_toSavedPartRollHash(hpatch_uint64_t _rollHash,size_t savedRollHashBits){
-    //byte order: 0123 -> 2301
-    hpatch_uint32_t rollHash=(hpatch_uint32_t)_rollHash;
-    rollHash= (rollHash<<16) | (rollHash>>16);
-    return rollHash<<(32-savedRollHashBits)>>(32-savedRollHashBits);
-}
-
-} //namespace sync_private
-#endif //zsync_client_type_private_h

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

@@ -1,247 +0,0 @@
-// zsync_client_wrapper.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.
- */
-#include "zsync_client_wrapper.h"
-#include "zsync_client_type_private.h"
-#include "zsync_info_client.h"
-#include "zsync_match_in_old.h"
-#include "../sync_client/sync_client_private.h"
-#include "../sync_client/sync_diff_data.h"
-#include "../../libHDiffPatch/HPatch/patch_private.h"
-#include "../../file_for_patch.h"
-#include <stdexcept>
-namespace sync_private{
-
-#define check(v,errorCode) \
-            do{ if (!(v)) { if (result==kSyncClient_ok) result=errorCode; \
-                            if (!_inClear) goto clear; } }while(0)
-
-void z_checkChecksumInit(unsigned char* checkChecksumBuf,size_t kStrongChecksumByteSize){
-    zsync_checkChecksum_t* self=(zsync_checkChecksum_t*)(checkChecksumBuf+2*kStrongChecksumByteSize);
-    assert((kStrongChecksumByteSize%sizeof(self->checkBlockIndex))==0);
-    self->checkBlockIndex=0;
-    self->state=0; //not run
-}
-
-void z_checkChecksumAppendData(unsigned char* checkChecksumBuf,uint32_t checksumIndex,
-                               hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum,
-                               const unsigned char* blockChecksum,const unsigned char* blockData,size_t blockDataSize){
-    const size_t kStrongChecksumByteSize=checkChecksumPlugin->checksumByteSize();
-    zsync_checkChecksum_t* self=(zsync_checkChecksum_t*)(checkChecksumBuf+2*kStrongChecksumByteSize);
-    assert(self->checkBlockIndex<=checksumIndex); //must check by order
-    self->checkBlockIndex++;
-    if (self->state==0){
-        assert(checksumIndex==0);
-        self->state=1; //checking
-        checkChecksumPlugin->begin(checkChecksum);
-    }
-    checkChecksumPlugin->append(checkChecksum,blockData,blockData+blockDataSize);
-}
-
-void z_checkChecksumEndTo(unsigned char* dst,unsigned char* checkChecksumBuf,
-                          hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum){
-    const size_t kStrongChecksumByteSize=checkChecksumPlugin->checksumByteSize();
-    zsync_checkChecksum_t* self=(zsync_checkChecksum_t*)(checkChecksumBuf+2*kStrongChecksumByteSize);
-    unsigned char* checksum=checkChecksumBuf+kStrongChecksumByteSize;
-    if (self->state==0){
-        self->state=1;
-        checkChecksumPlugin->begin(checkChecksum);
-    }
-    if (self->state==1){
-        checkChecksumPlugin->end(checkChecksum,checksum,checksum+kStrongChecksumByteSize);
-        self->state=2; //end
-    }
-    assert(self->state==2);
-    memcpy(dst,checksum,kStrongChecksumByteSize);
-}
-
-
-static TSyncClient_resultType z_writeToNewOrDiff(_TWriteDatas& wd) {
-    _IWriteToNewOrDiff_by wr_by={0};
-    wr_by.checkChecksumAppendData=
-        ((const TNewDataZsyncInfo*)wd.newSyncInfo)->fileChecksumPlugin?z_checkChecksumAppendData:0;
-    return _writeToNewOrDiff_by(&wr_by,wd);
-}
-
-TSyncClient_resultType
-    _zsync_patch(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,TSyncDiffData* diffData,
-                 const hpatch_TStreamInput* oldStream,const TNewDataZsyncInfo* newSyncInfo,
-                 const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,
-                 const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
-                 const hpatch_TStreamInput* diffContinue,int threadNum){
-    _ISyncPatch_by sp_by={0};
-    sp_by.matchNewDataInOld=z_matchNewDataInOld;
-    sp_by.writeToNewOrDiff=z_writeToNewOrDiff;
-    sp_by.checkChecksumInit=newSyncInfo->fileChecksumPlugin?z_checkChecksumInit:0;
-    sp_by.checkChecksumEndTo=newSyncInfo->fileChecksumPlugin?z_checkChecksumEndTo:0;
-    return _sync_patch_by(&sp_by, listener,syncDataListener,diffData,oldStream,newSyncInfo,
-                          out_newStream,newDataContinue,out_diffStream,diffType,diffContinue,threadNum);
-}
-
-}//end namespace sync_private
-using namespace sync_private;
-
-TSyncClient_resultType zsync_patch(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
-                                   const hpatch_TStreamInput* oldStream,const TNewDataZsyncInfo* newSyncInfo,
-                                   const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,
-                                   const hpatch_TStreamOutput* out_diffInfoStream,const hpatch_TStreamInput* diffInfoContinue,int threadNum){
-    return _zsync_patch(listener,syncDataListener,0,oldStream,newSyncInfo,out_newStream,newDataContinue,
-                        out_diffInfoStream,kSyncDiff_info,diffInfoContinue,threadNum);
-}
-
-TSyncClient_resultType zsync_local_diff(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
-                                        const hpatch_TStreamInput* oldStream,const TNewDataZsyncInfo* newSyncInfo,
-                                        const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
-                                        const hpatch_TStreamInput* diffContinue,int threadNum){
-    return _zsync_patch(listener,syncDataListener,0,oldStream,newSyncInfo,0,0,
-                        out_diffStream,diffType,diffContinue,threadNum);
-}
-
-
-TSyncClient_resultType zsync_local_patch(ISyncInfoListener* listener,const hpatch_TStreamInput* in_diffStream,
-                                         const hpatch_TStreamInput* oldStream,const TNewDataZsyncInfo* newSyncInfo,
-                                         const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,int threadNum){
-    TSyncDiffData diffData;
-    if (!_TSyncDiffData_load(&diffData,in_diffStream)) return kSyncClient_loadDiffError;
-    return _zsync_patch(listener,0,&diffData,oldStream,newSyncInfo,out_newStream,newDataContinue,
-                      0,kSyncDiff_default,0,threadNum);
-}
-
-namespace sync_private{
-
-static TSyncClient_resultType
-    _zsync_patch_file2file(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
-                           TSyncDiffData* diffData,const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
-                           const char* outNewFile,hpatch_BOOL isOutNewContinue,
-                           const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
-                           const hpatch_TStreamInput* diffContinue,int threadNum){
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    TNewDataZsyncInfo           newSyncInfo;
-    hpatch_TFileStreamInput     oldData;
-    hpatch_TFileStreamOutput    out_newData;
-    const hpatch_TStreamInput*  newDataContinue=0;
-    hpatch_TStreamInput         _newDataContinue;
-    const hpatch_TStreamInput*  oldStream=0;
-    bool isOldPathInputEmpty=(oldFile==0)||(strlen(oldFile)==0);
-    
-    TNewDataZsyncInfo_init(&newSyncInfo);
-    hpatch_TFileStreamInput_init(&oldData);
-    hpatch_TFileStreamOutput_init(&out_newData);
-    result=TNewDataZsyncInfo_open_by_file(&newSyncInfo,newSyncInfoFile,isIgnoreCompressInfo,listener);
-    check(result==kSyncClient_ok,result);
-    
-    if (!isOldPathInputEmpty)
-        check(hpatch_TFileStreamInput_open(&oldData,oldFile),kSyncClient_oldFileOpenError);
-    oldStream=&oldData.base;
-    if (outNewFile){
-        check(_open_continue_out(isOutNewContinue,outNewFile,&out_newData,&_newDataContinue,newSyncInfo.newDataSize),
-              isOutNewContinue?kSyncClient_newFileReopenWriteError:kSyncClient_newFileCreateError);
-        if (isOutNewContinue) newDataContinue=&_newDataContinue;
-    }
-    
-    result=_zsync_patch(listener,syncDataListener,diffData,oldStream,&newSyncInfo,
-                        outNewFile?&out_newData.base:0,newDataContinue,
-                        out_diffStream,diffType,diffContinue,threadNum);
-clear:
-    _inClear=1;
-    check(hpatch_TFileStreamOutput_close(&out_newData),kSyncClient_newFileCloseError);
-    check(hpatch_TFileStreamInput_close(&oldData),kSyncClient_oldFileCloseError);
-    TNewDataZsyncInfo_close(&newSyncInfo);
-    return result;
-}
-
-}//end namespace sync_private
-
-TSyncClient_resultType zsync_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){
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    hpatch_TFileStreamOutput out_diffInfo;
-    hpatch_TFileStreamOutput_init(&out_diffInfo);
-    const hpatch_TStreamInput* diffContinue=0;
-    hpatch_TStreamInput _diffContinue;
-    if (cacheDiffInfoFile){
-        hpatch_BOOL isOutDiffContinue=hpatch_TRUE;
-        check(_open_continue_out(isOutDiffContinue,cacheDiffInfoFile,&out_diffInfo,&_diffContinue),
-            isOutDiffContinue?kSyncClient_diffFileReopenWriteError:kSyncClient_diffFileCreateError);
-        if (isOutDiffContinue) diffContinue=&_diffContinue;
-    }
-
-    result=_zsync_patch_file2file(listener,syncDataListener,0,oldFile,newSyncInfoFile,isIgnoreCompressInfo,
-                                  outNewFile,isOutNewContinue,
-                                  cacheDiffInfoFile?&out_diffInfo.base:0,kSyncDiff_info,diffContinue,threadNum);
-clear:
-    _inClear=1;
-    check(hpatch_TFileStreamOutput_close(&out_diffInfo),kSyncClient_diffFileCloseError);
-    return result;
-}
-
-TSyncClient_resultType zsync_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){
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    hpatch_TFileStreamOutput out_diff;
-    hpatch_TFileStreamOutput_init(&out_diff);
-    const hpatch_TStreamInput* diffContinue=0;
-    hpatch_TStreamInput _diffContinue;
-    
-    check(_open_continue_out(isOutDiffContinue,outDiffFile,&out_diff,&_diffContinue),
-          isOutDiffContinue?kSyncClient_diffFileReopenWriteError:kSyncClient_diffFileCreateError);
-    if (isOutDiffContinue) diffContinue=&_diffContinue;
-    
-    result=_zsync_patch_file2file(listener,syncDataListener,0,oldFile,newSyncInfoFile,isIgnoreCompressInfo,0,hpatch_FALSE,
-                                  &out_diff.base,diffType,diffContinue,threadNum);
-
-clear:
-    _inClear=1;
-    check(hpatch_TFileStreamOutput_close(&out_diff),kSyncClient_diffFileCloseError);
-    return result;
-}
-
-TSyncClient_resultType zsync_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){
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    TSyncDiffData diffData;
-    hpatch_TFileStreamInput in_diffData;
-    hpatch_TFileStreamInput_init(&in_diffData);
-    check(hpatch_TFileStreamInput_open(&in_diffData,inDiffFile),
-          kSyncClient_diffFileOpenError);
-    check(_TSyncDiffData_load(&diffData,&in_diffData.base),kSyncClient_loadDiffError);
-    result=_zsync_patch_file2file(listener,0,&diffData,oldFile,newSyncInfoFile,isIgnoreCompressInfo,outNewFile,isOutNewContinue,
-                                 0,kSyncDiff_default,0,threadNum);
-clear:
-    _inClear=1;
-    check(hpatch_TFileStreamInput_close(&in_diffData),kSyncClient_diffFileCloseError);
-    return result;
-}

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

@@ -1,71 +0,0 @@
-// zsync_client_wrapper.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_client_wrapper_h
-#define zsync_client_wrapper_h
-#include "zsync_info_client.h"
-
-//zsync_patch(oldStream+syncDataListener) to out_newStream
-TSyncClient_resultType zsync_patch(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
-                                   const hpatch_TStreamInput* oldStream,const TNewDataZsyncInfo* newSyncInfo,
-                                   const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,
-                                   const hpatch_TStreamOutput* out_diffInfoStream,const hpatch_TStreamInput* diffInfoContinue,int threadNum);
-
-//zsync patch(oldFile+syncDataListener) to outNewFile
-TSyncClient_resultType zsync_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);
-
-//zsync_patch can split to two steps: zsync_local_diff + zsync_local_patch
-
-
-//download diff data from syncDataListener to out_diffStream
-//  if (diffContinue) then continue download
-TSyncClient_resultType zsync_local_diff(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
-                                        const hpatch_TStreamInput* oldStream,const TNewDataZsyncInfo* newSyncInfo,
-                                        const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
-                                        const hpatch_TStreamInput* diffContinue,int threadNum);
-
-//patch(oldStream+in_diffStream) to out_newStream
-TSyncClient_resultType zsync_local_patch(ISyncInfoListener* listener,const hpatch_TStreamInput* in_diffStream,
-                                         const hpatch_TStreamInput* oldStream,const TNewDataZsyncInfo* 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 zsync_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 zsync_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