react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/match_block.h

@@ -1,222 +0,0 @@
-// match_block.h
-// hdiff
-/*
- The MIT License (MIT)
- Copyright (c) 2021 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 hdiff_match_block_h
-#define hdiff_match_block_h
-#include "diff.h"
-#include <vector>
-static const size_t kDefaultFastMatchBlockSize = 1024*1;
-namespace hdiff_private{
-    struct TAutoMem;
-    
-    struct TMatchBlockBase{
-        typedef hpatch_TCover TPackedCover;
-        TMatchBlockBase(size_t _matchBlockSize,size_t _threadNum)
-        :matchBlockSize(_matchBlockSize),threadNum(_threadNum){}
-    protected:
-        void _getPackedCover(hpatch_StreamPos_t newDataSize,hpatch_StreamPos_t oldDataSize);
-        void _unpackData(IDiffInsertCover* diffi,void*& pcovers,size_t& coverCount,bool isCover32);
-        const size_t   matchBlockSize;
-        const size_t   threadNum;
-        std::vector<hpatch_TCover> blockCovers;
-        std::vector<TPackedCover> packedCoversForOld;
-        std::vector<TPackedCover> packedCoversForNew;
-    };
-
-    //remove some big match block befor diff, in memory
-    struct TMatchBlockMem:public TMatchBlockBase{
-        unsigned char* newData;
-        unsigned char* newData_end;
-        unsigned char* newData_end_cur;
-        unsigned char* oldData;
-        unsigned char* oldData_end;
-        unsigned char* oldData_end_cur;
-        TMatchBlockMem(unsigned char* _newData,unsigned char* _newData_end,
-                       unsigned char* _oldData,unsigned char* _oldData_end,
-                       size_t _matchBlockSize,size_t _threadNumForMem)
-        :TMatchBlockBase(_matchBlockSize,_threadNumForMem),
-         newData(_newData),newData_end(_newData_end),newData_end_cur(_newData_end),
-         oldData(_oldData),oldData_end(_oldData_end),oldData_end_cur(_oldData_end){ }
-        inline hpatch_StreamPos_t curNewDataSize()const{ return (size_t)(newData_end_cur-newData); }
-        inline hpatch_StreamPos_t curOldDataSize()const{ return (size_t)(oldData_end_cur-oldData); }
-        void getBlockCovers();
-        inline void getPackedCover() { _getPackedCover(newData_end-newData,oldData_end-oldData); }
-        void packData();
-        void unpackData(IDiffInsertCover* diffi,void* pcovers,size_t coverCount,bool isCover32);
-    };
-
-    //remove some big match block befor diff, used stream
-    struct TMatchBlockStream:public TMatchBlockBase{
-        unsigned char* newData;
-        unsigned char* newData_end_cur;
-        unsigned char* oldData;
-        unsigned char* oldData_end_cur;
-        const hpatch_TStreamInput* newStream;
-        const hpatch_TStreamInput* oldStream;
-        const size_t    threadNumForStream;
-        TMatchBlockStream(const hpatch_TStreamInput* _newStream,const hpatch_TStreamInput* _oldStream,
-                          size_t _matchBlockSize,size_t _threadNumForMem,size_t _threadNumForStream);
-        ~TMatchBlockStream();
-        inline hpatch_StreamPos_t curNewDataSize()const{ return _isUnpacked?newStream->streamSize:(size_t)(newData_end_cur-newData); }
-        inline hpatch_StreamPos_t curOldDataSize()const{ return _isUnpacked?oldStream->streamSize:(size_t)(oldData_end_cur-oldData); }
-        void getBlockCovers();
-        inline void getPackedCover() { _getPackedCover(newStream->streamSize,oldStream->streamSize); }
-        void packData();
-        void unpackData(IDiffInsertCover* diffi,void* pcovers,size_t coverCount,bool isCover32);
-        void map_streams(const hpatch_TStreamInput** pnewData,const hpatch_TStreamInput** poldData);
-
-        struct TStreamInputMap:public hpatch_TStreamInput{
-            const hpatch_TStreamInput*  baseStream;
-            std::vector<TPackedCover>&  packedCovers;
-            size_t                      curCoverIndex;
-            const unsigned char*        data; //packed data
-            const unsigned char*        data_end;
-            inline TStreamInputMap(const hpatch_TStreamInput* _baseStream,std::vector<TPackedCover>& _packedCovers)
-                :baseStream(_baseStream),packedCovers(_packedCovers),curCoverIndex(0){}
-        };
-    protected:
-        TStreamInputMap _newStreamMap;
-        TStreamInputMap _oldStreamMap;
-        TAutoMem*       _packedNewOldMem;
-        bool            _isUnpacked;
-    };
-
-    template<class _TMatchBlock>
-    struct TCoversOptim:public ICoverLinesListener{
-        explicit TCoversOptim(_TMatchBlock* _matchBlock):matchBlock(_matchBlock){
-            ICoverLinesListener* listener=this;
-            memset(listener,0,sizeof(*listener));
-            insert_cover=_insert_cover;
-        }
-        _TMatchBlock* matchBlock;
-    protected:
-        static void _insert_cover(ICoverLinesListener* listener,IDiffInsertCover* diffi,void* pcovers,size_t coverCount,
-                                  bool isCover32,hpatch_StreamPos_t* newSize,hpatch_StreamPos_t* oldSize){
-            TCoversOptim<_TMatchBlock>* self=(TCoversOptim<_TMatchBlock>*)listener;
-            if (self->matchBlock!=0){
-                assert(self->matchBlock->curNewDataSize()==*newSize);
-                assert(self->matchBlock->curOldDataSize()==*oldSize);
-                self->matchBlock->unpackData(diffi,pcovers,coverCount,isCover32);
-                *newSize=self->matchBlock->curNewDataSize();
-                *oldSize=self->matchBlock->curOldDataSize();
-            }
-        }
-        inline void _doPack(){
-            matchBlock->getBlockCovers();
-            matchBlock->getPackedCover();
-            matchBlock->packData();
-        }
-    };
-
-    struct TCoversOptimMem:public TCoversOptim<TMatchBlockMem>{
-        TCoversOptimMem(unsigned char* newData,unsigned char* newData_end,
-                       unsigned char* oldData,unsigned char* oldData_end,
-                       size_t matchBlockSize,size_t threadNum)
-        :TCoversOptim<TMatchBlockMem>(&_matchBlock),
-         _matchBlock(newData,newData_end,oldData,oldData_end,matchBlockSize,threadNum){
-            _doPack();
-        }
-    protected:
-        TMatchBlockMem _matchBlock;
-    };
-
-    struct TCoversOptimStream:public TCoversOptim<TMatchBlockStream>{
-        TCoversOptimStream(const hpatch_TStreamInput* newStream,const hpatch_TStreamInput* oldStream,
-                       size_t matchBlockSize,size_t threadNumForMem,size_t threadNumForStream)
-        :TCoversOptim<TMatchBlockStream>(&_matchBlock),
-         _matchBlock(newStream,oldStream,matchBlockSize,threadNumForMem,threadNumForStream){
-            map_streams_befor_serialize=_map_streams_befor_serialize;//for ICoverLinesListener
-            _doPack();
-        }
-    protected:
-        TMatchBlockStream _matchBlock;
-        static void _map_streams_befor_serialize(ICoverLinesListener* listener,const hpatch_TStreamInput** pnewData,const hpatch_TStreamInput** poldData){
-            TCoversOptimStream* self=(TCoversOptimStream*)listener;
-            self->_matchBlock.map_streams(pnewData,poldData);
-        }
-    };
-    
-    void loadOldAndNewStream(TAutoMem& out_mem,const hpatch_TStreamInput* oldStream,const hpatch_TStreamInput* newStream);
-
-} //namespace hdiff_private
-
-
-//optimize diff speed by match block
-//note: newData&oldData in memory will be changed
-//see create_compressed_diff | create_single_compressed_diff
-
-void create_compressed_diff_block(const hpatch_TStreamInput* newData,//will load needed in memory
-                                  const hpatch_TStreamInput* oldData,//will load needed in memory
-                                  const hpatch_TStreamOutput* out_diff,
-                                  const hdiff_TCompress* compressPlugin=0,
-                                  int kMinSingleMatchScore=kMinSingleMatchScore_default,
-                                  bool isUseBigCacheMatch=false,
-                                  size_t matchBlockSize=kDefaultFastMatchBlockSize,
-                                  size_t threadNumForMem=1,size_t threadNumForStream=1);
-void create_compressed_diff_block(unsigned char* newData,unsigned char* newData_end,
-                                  unsigned char* oldData,unsigned char* oldData_end,
-                                  const hpatch_TStreamOutput* out_diff,
-                                  const hdiff_TCompress* compressPlugin=0,
-                                  int kMinSingleMatchScore=kMinSingleMatchScore_default,
-                                  bool isUseBigCacheMatch=false,
-                                  size_t matchBlockSize=kDefaultFastMatchBlockSize,
-                                  size_t threadNum=1);
-void create_compressed_diff_block(unsigned char* newData,unsigned char* newData_end,
-                                  unsigned char* oldData,unsigned char* oldData_end,
-                                  std::vector<unsigned char>& out_diff,
-                                  const hdiff_TCompress* compressPlugin=0,
-                                  int kMinSingleMatchScore=kMinSingleMatchScore_default,
-                                  bool isUseBigCacheMatch=false,
-                                  size_t matchBlockSize=kDefaultFastMatchBlockSize,
-                                  size_t threadNum=1);
-
-void create_single_compressed_diff_block(const hpatch_TStreamInput* newData,//will load needed in memory
-                                         const hpatch_TStreamInput* oldData,//will load needed in memory
-                                         const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin=0,
-                                         int kMinSingleMatchScore=kMinSingleMatchScore_default,
-                                         size_t patchStepMemSize=kDefaultPatchStepMemSize,
-                                         bool isUseBigCacheMatch=false,
-                                         size_t matchBlockSize=kDefaultFastMatchBlockSize,
-                                         size_t threadNumForMem=1,size_t threadNumForStream=1);
-void create_single_compressed_diff_block(unsigned char* newData,unsigned char* newData_end,
-                                         unsigned char* oldData,unsigned char* oldData_end,
-                                         const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin=0,
-                                         int kMinSingleMatchScore=kMinSingleMatchScore_default,
-                                         size_t patchStepMemSize=kDefaultPatchStepMemSize,
-                                         bool isUseBigCacheMatch=false,
-                                         size_t matchBlockSize=kDefaultFastMatchBlockSize,
-                                         size_t threadNum=1);
-void create_single_compressed_diff_block(unsigned char* newData,unsigned char* newData_end,
-                                         unsigned char* oldData,unsigned char* oldData_end,
-                                         std::vector<unsigned char>& out_diff,const hdiff_TCompress* compressPlugin=0,
-                                         int kMinSingleMatchScore=kMinSingleMatchScore_default,
-                                         size_t patchStepMemSize=kDefaultPatchStepMemSize,
-                                         bool isUseBigCacheMatch=false,
-                                         size_t matchBlockSize=kDefaultFastMatchBlockSize,
-                                         size_t threadNum=1);
-
-#endif //hdiff_match_block_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/libdivsufsort/divsufsort64.cpp

@@ -1,14 +0,0 @@
-#define BUILD_DIVSUFSORT64
-#define HAVE_CONFIG_H 1
-# include "divsufsort64.h"
-typedef saidx64_t saidx_t;
-typedef saidx_t sastore_t;
-# define divsufsort divsufsort64
-# define divsufsort_version divsufsort64_version
-# define sssort sssort64
-# define trsort trsort64
-
-#include "divsufsort_private.h"
-#include "divsufsort.c.inc.h"
-#include "sssort.c.inc.h"
-#include "trsort.c.inc.h"

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/match_inplace.cpp

@@ -1,168 +0,0 @@
-// match_inplace.cpp
-// hdiff
-/*
- The MIT License (MIT)
- Copyright (c) 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.
- */
-#include "match_inplace.h"
-#include <algorithm> //std::min std::max std::sort
-using namespace hdiff_private;
-
-namespace{
-    static const hpatch_StreamPos_t _kMinCoverLen     =24;
-    static const int _kMaxMatchDeepForResearch = kDefaultMaxMatchDeepForLimit*2;
-
-    static inline bool coverInExtraSafeSize(const hpatch_TCover& cover,hpatch_StreamPos_t kExtraSafeSize){
-        return cover.oldPos+kExtraSafeSize>=cover.newPos;
-    }
-
-    static inline TInplaceSets _limitSets(size_t oldSize, size_t newSize, const TInplaceSets& inplaceSets) {
-        TInplaceSets limitedSets=inplaceSets;
-        limitedSets.extraSafeSize=std::min(limitedSets.extraSafeSize,newSize);
-        return limitedSets;
-    }
-
-//ICoverLinesListener
-static bool _search_cover_limit(ICoverLinesListener* listener,const void* pcovers,size_t coverCount,bool isCover32){
-    TMatchInplace* self=(TMatchInplace*)listener;
-    const hpatch_StreamPos_t kExtraSafeSize=self->inplaceSets.extraSafeSize;
-    std::vector<size_t> researchIndexList;
-    TRefCovers covers(pcovers,coverCount,isCover32);
-    hpatch_StreamPos_t researchLength=0;
-    hpatch_StreamPos_t inExtraSafeLength=0;
-    for (size_t i=0;i<coverCount;++i){
-        hpatch_TCover curCover=covers[i];
-        if (coverInExtraSafeSize(curCover,kExtraSafeSize)){//ok
-            inExtraSafeLength+=curCover.length;
-        }else{
-            researchLength+=curCover.length;
-            researchIndexList.push_back(i);
-        }
-    }
-    self->inExtraSafeLength=inExtraSafeLength;
-    self->researchLength=researchLength;
-    self->researchCount=researchIndexList.size();
-    self->_researchIndexList.swap(researchIndexList);
-    return (!self->_researchIndexList.empty());
-}
-
-
-    struct TDiffSearchCoverListener :public IDiffSearchCoverListener{
-        const size_t kExtraSafeSize;
-        inline explicit TDiffSearchCoverListener(size_t _extraMemSize):kExtraSafeSize(_extraMemSize){ 
-            limitCover=_limitCover;
-            limitCover_front=_limitCover_front;
-        }
-        static bool _limitCover(struct IDiffSearchCoverListener* listener,
-                                const hpatch_TCover* cover,hpatch_StreamPos_t* out_leaveLen){
-            TDiffSearchCoverListener* self=(TDiffSearchCoverListener*)listener;
-            bool isOk=(cover->length>=_kMinCoverLen)&&coverInExtraSafeSize(*cover,self->kExtraSafeSize);
-            if (out_leaveLen) *out_leaveLen=isOk?cover->length:0;
-            return isOk;
-        }
-        static void _limitCover_front(struct IDiffSearchCoverListener* listener,
-                                      const hpatch_TCover* front_cover,hpatch_StreamPos_t* out_leaveLen){
-            TDiffSearchCoverListener* self=(TDiffSearchCoverListener*)listener;
-            assert(coverInExtraSafeSize(*front_cover,self->kExtraSafeSize));
-            *out_leaveLen=front_cover->length;
-        }
-    };
-static void _research_cover(ICoverLinesListener* listener,IDiffResearchCover* diffi,const void* pcovers,size_t coverCount,bool isCover32){
-    TMatchInplace* self=(TMatchInplace*)listener;
-    TRefCovers covers(pcovers,coverCount,isCover32);
-    TDiffSearchCoverListener diffSearchCoverListener(self->inplaceSets.extraSafeSize);
-    std::vector<size_t> researchIndexList;
-    researchIndexList.swap(self->_researchIndexList);
-    for (size_t i=0;i<researchIndexList.size();++i){
-        size_t limitCoverIndex=researchIndexList[i];
-        hpatch_TCover cover=covers[limitCoverIndex];
-        diffi->researchCover(diffi,&diffSearchCoverListener,limitCoverIndex,0,0,cover.length);
-    }
-}
-
-static int _get_max_match_deep(const ICoverLinesListener* listener){
-    return _kMaxMatchDeepForResearch;
-}
-
-static void _search_cover_finish(ICoverLinesListener* listener,void* pcovers,size_t* pcoverCount,bool isCover32,
-                                 hpatch_StreamPos_t* newSize,hpatch_StreamPos_t* oldSize){
-    TMatchInplace* self=(TMatchInplace*)listener;
-    const hpatch_size_t kExtraSafeSize=self->inplaceSets.extraSafeSize;
-
-    //check covers
-    hpatch_StreamPos_t minExtraSafeSize=0;
-    TRefCovers _covers(pcovers,*pcoverCount,isCover32);
-    for (size_t i=0;i<_covers.size();++i){
-        hpatch_TCover cover=_covers[i];
-        if (!coverInExtraSafeSize(cover,kExtraSafeSize))
-            throw std::runtime_error("TMatchInplace limit cover by extraSafeSize ERROR!");
-        if (cover.oldPos<cover.newPos)
-            minExtraSafeSize=std::max(minExtraSafeSize,(hpatch_StreamPos_t)(cover.newPos-cover.oldPos));
-    }
-    if (minExtraSafeSize>kExtraSafeSize)
-       throw std::runtime_error("TMatchInplace extraSafeSize value ERROR!");
-    self->curExtraSafeSize=minExtraSafeSize;
-}
-
-static bool _getInplacePatchExtraSafeSize(ILiteDiffListener* listener,hpi_size_t* out_extraSafeSize){
-    const TMatchInplace* self=(const TMatchInplace*)listener;
-    if (self->inplaceSets.isCompatibleLiteDiff)
-        return false; //not save extraSafeSize
-    *out_extraSafeSize=(hpi_size_t)self->curExtraSafeSize;
-    return true; //save extraSafeSize
-}
-
-}//namespace
-
-
-TMatchInplace::TMatchInplace(size_t _oldSize,size_t _newSize,const TInplaceSets& _inplaceSets)
-:oldSize(_oldSize),newSize(_newSize),inplaceSets(_limitSets(_oldSize,_newSize,_inplaceSets)){
-    this->curExtraSafeSize=inplaceSets.extraSafeSize;
-    this->getInplacePatchExtraSafeSize=0;
-    ICoverLinesListener* cl=this;
-    memset(cl,0,sizeof(*cl));
-    this->search_cover_limit=_search_cover_limit;
-    this->research_cover=_research_cover;
-    this->get_max_match_deep=_get_max_match_deep;
-    this->search_cover_finish=_search_cover_finish;
-    this->getInplacePatchExtraSafeSize=_getInplacePatchExtraSafeSize;
-}
-
-void create_inplace_lite_diff(const hpi_byte* newData,const hpi_byte* newData_end,
-                              const hpi_byte* oldData,const hpi_byte* oldData_end,
-                              std::vector<hpi_byte>& out_inplace_lite_diff,const TInplaceSets& inplaceSets,
-                              const hdiffi_TCompress* compressPlugin,int kMinSingleMatchScore,
-                              bool isUseBigCacheMatch,size_t threadNum){
-    TMatchInplace matchInplace(oldData_end-oldData,newData_end-newData,inplaceSets);
-    create_lite_diff(newData,newData_end,oldData,oldData_end,out_inplace_lite_diff,compressPlugin,
-                     kMinSingleMatchScore,isUseBigCacheMatch,&matchInplace,threadNum);
-
-#ifdef _DEBUG
-    printf("\nDEBUG TMatchInplace info:\n"
-           "    cur extraSafeSize    : %" PRIu64 "\n",matchInplace.curExtraSafeSize);
-    printf("    extraSafe data length: %" PRIu64 "\n",matchInplace.inExtraSafeLength);
-    printf("    research  cover count: %" PRIu64 "\n",(hpatch_StreamPos_t)matchInplace.researchCount);
-    printf("    research  data length: %" PRIu64 "\n\n",matchInplace.researchLength);
-#endif
-}

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/match_inplace.h

@@ -1,44 +0,0 @@
-// match_inplace.h
-// hdiff
-/*
- The MIT License (MIT)
- Copyright (c) 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 hdiff_match_inplace_h
-#define hdiff_match_inplace_h
-#include "../diff_for_hpatch_lite.h" //diffi API
-
-    struct TMatchInplace:public ILiteDiffListener {
-        const size_t oldSize;
-        const size_t newSize;
-        const TInplaceSets inplaceSets;
-        explicit TMatchInplace(size_t _oldSize,size_t _newSize,const TInplaceSets& _inplaceSets);
-        std::vector<size_t> _researchIndexList;
-        size_t              researchCount;
-        hpatch_StreamPos_t  researchLength;
-        hpatch_StreamPos_t  inExtraSafeLength;
-        hpatch_StreamPos_t  curExtraSafeSize;
-    };
-
-#endif //hdiff_match_inplace_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/qsort_parallel.h

@@ -1,125 +0,0 @@
-//  qsort_parallel.h
-//  parallel sort for HDiffz
-/*
- The MIT License (MIT)
- Copyright (c) 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 HDiff_qsort_parallel_h
-#define HDiff_qsort_parallel_h
-#include <algorithm>
-#include "../../../libParallel/parallel_import.h"
-#if (_IS_USED_MULTITHREAD)
-#include <thread>   //if used vc++, need >= vc2012
-#endif
-
-#if (_IS_USED_MULTITHREAD)
-    inline static size_t __index_by_ratio(size_t size,size_t ratio,size_t ratio_base){
-        return (size_t)(((hpatch_uint64_t)size)*ratio/ratio_base);
-    }
-
-    template<class TValue,class TCmp>
-    struct _sort_parallel_TCmpi{
-        inline _sort_parallel_TCmpi(const TValue* begin,TCmp& cmp):_begin(begin),_cmp(cmp){}
-        inline bool operator()(const size_t& x,const size_t& y) const{
-            return _cmp(_begin[x],_begin[y]);
-        }
-        const TValue* _begin;
-        TCmp& _cmp;
-    };
-
-    template<class TValue,class TCmp,size_t kSampleSize>
-    static TValue* _sort_parallel_partition(TValue* begin,TValue* end,TCmp cmp,
-                                             size_t leftWeight=1,size_t rightWeight=1){
-        const size_t size=end-begin;
-        size_t samples[kSampleSize];
-        const size_t _kIndexStep=size/kSampleSize+1;
-        size_t curIndex=0;
-        for(size_t i=0;i<kSampleSize;i++,curIndex+=_kIndexStep){
-            size_t ri=(curIndex+(size_t)rand()) % size;  //multi thread safe
-            samples[i]=ri;
-        }
-        const bool _kIsSortNotNth=false;
-        if (_kIsSortNotNth) std::sort(samples,samples+kSampleSize,_sort_parallel_TCmpi<TValue,TCmp>(begin,cmp));
-        size_t _pivot_i=__index_by_ratio(kSampleSize,leftWeight,(leftWeight+rightWeight));
-        if (!_kIsSortNotNth) std::nth_element(samples,samples+_pivot_i,samples+kSampleSize,_sort_parallel_TCmpi<TValue,TCmp>(begin,cmp));
-        size_t pivot=samples[_pivot_i];
-        std::swap(begin[0],begin[pivot]);
-        TValue x(begin[0]);
-        size_t mid=0;
-        for (size_t i=mid+1;i<size;++i){
-            if (cmp(begin[i],x))
-                std::swap(begin[++mid],begin[i]);
-        }
-        std::swap(begin[0],begin[mid]);
-        return begin+mid;
-    }
-
-    template<class TValue,class TCmp,size_t kSampleSize>
-    static void _sort_parallel_thread(TValue* begin,TValue* end,TCmp cmp,size_t threadNum){
-        if (threadNum>1){
-            const size_t rightWeight=(threadNum>>1);
-            const size_t leftWeight=threadNum-rightWeight;
-            TValue* mid;
-            const bool _kIsPartitionNotMerge=true;
-            if (_kIsPartitionNotMerge){ // partition
-                //mid=begin+__index_by_ratio(size,leftWeight,threadNum); std::nth_element(begin,mid,end,cmp); //for test 
-                //mid=std::_Partition_by_median_guess_unchecked(begin, end, cmp).first; //for test by vc
-                mid=_sort_parallel_partition<TValue,TCmp,kSampleSize>(begin,end,cmp,leftWeight,rightWeight);
-            }else{
-                mid=begin+__index_by_ratio(end-begin,leftWeight,threadNum);
-            }
-
-            std::thread threadRight(_sort_parallel_thread<TValue,TCmp,kSampleSize>,
-                                    mid,end,cmp,rightWeight);
-            _sort_parallel_thread<TValue,TCmp,kSampleSize>(begin,mid,cmp,leftWeight);
-            threadRight.join();
-            
-            if (!_kIsPartitionNotMerge){ //merge
-                std::inplace_merge(begin,mid,end,cmp);
-            }
-        }else{
-            std::sort(begin,end,cmp);
-            //printf("parallel sort size: %" PRIu64 " \n",(hpatch_StreamPos_t)(end-begin));
-        }
-    }
-#endif
-
-    template<class TValue,class TCmp,size_t kMinQSortParallelSize,size_t kSampleSize>
-    static void sort_parallel(TValue* begin,TValue* end,TCmp cmp,size_t threadNum){
-#if (_IS_USED_MULTITHREAD)
-        const size_t size=end-begin;
-        if ((threadNum>1)&&(size>=kMinQSortParallelSize)){
-            const size_t maxThreanNum=size/(kMinQSortParallelSize/2);
-            threadNum=(threadNum<=maxThreanNum)?threadNum:maxThreanNum;
-            //std::random_shuffle(begin,end); //test shuffle befor parallel sort?
-            _sort_parallel_thread<TValue,TCmp,kSampleSize>(begin,end,cmp,threadNum);
-        }else
-#endif
-        {
-            std::sort(begin,end,cmp);
-        }
-    }
-
-#endif