react-native-update 8.5.5 → 8.5.7

package/harmony/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/new_dir_output.c

@@ -1,331 +0,0 @@
-// new_dir_output.c
-// hdiffz dir patch
-//
-/*
- The MIT License (MIT)
- Copyright (c) 2018-2019 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 "new_dir_output.h"
-#include "../../file_for_patch.h"
-#if (_IS_NEED_DIR_DIFF_PATCH)
-#include "dir_patch_tools.h"
-#include <stdio.h>
-#include <string.h>
-
-#define TUInt hpatch_StreamPos_t
-
-#define  check(value) { if (!(value)){ fprintf(stderr,"check "#value" error!\n");  \
-                                       result=hpatch_FALSE; goto clear; } }
-
-static hpatch_BOOL _TDirPatcher_copyFile(const char* oldFileName_utf8,const char* newFileName_utf8,
-                                         hpatch_ICopyDataListener* copyListener){
-#define _tempCacheSize (hpatch_kStreamCacheSize*4)
-    hpatch_BOOL result=hpatch_TRUE;
-    TByte        temp_cache[_tempCacheSize];
-    hpatch_StreamPos_t pos=0;
-    hpatch_TFileStreamInput   oldFile;
-    hpatch_TFileStreamOutput  newFile;
-    hpatch_TFileStreamInput_init(&oldFile);
-    hpatch_TFileStreamOutput_init(&newFile);
-    
-    check(hpatch_TFileStreamInput_open(&oldFile,oldFileName_utf8));
-    if (newFileName_utf8)
-        check(hpatch_TFileStreamOutput_open(&newFile,newFileName_utf8,oldFile.base.streamSize));
-    while (pos<oldFile.base.streamSize) {
-        size_t copyLen=_tempCacheSize;
-        if (pos+copyLen>oldFile.base.streamSize)
-            copyLen=(size_t)(oldFile.base.streamSize-pos);
-        check(oldFile.base.read(&oldFile.base,pos,temp_cache,temp_cache+copyLen));
-        if (newFileName_utf8)
-            check(newFile.base.write(&newFile.base,pos,temp_cache,temp_cache+copyLen));
-        if (copyListener)
-            copyListener->copyedData(copyListener,temp_cache,temp_cache+copyLen);
-        pos+=copyLen;
-    }
-    check(!oldFile.fileError);
-    check(!newFile.fileError);
-    if (newFileName_utf8)
-        check(newFile.out_length==newFile.base.streamSize);
-clear:
-    hpatch_TFileStreamOutput_close(&newFile);
-    hpatch_TFileStreamInput_close(&oldFile);
-    return result;
-#undef _tempCacheSize
-}
-
-hpatch_BOOL TDirPatcher_copyFile(const char* oldFileName_utf8,const char* newFileName_utf8,
-                                 hpatch_ICopyDataListener* copyListener){
-    hpatch_BOOL result=hpatch_TRUE;
-    check(newFileName_utf8!=0);
-    result=_TDirPatcher_copyFile(oldFileName_utf8,newFileName_utf8,copyListener);
-clear:
-    return result;
-}
-hpatch_BOOL TDirPatcher_readFile(const char* oldFileName_utf8,hpatch_ICopyDataListener* copyListener){
-    return _TDirPatcher_copyFile(oldFileName_utf8,0,copyListener);
-}
-
-static hpatch_BOOL _makeNewDirOrEmptyFile(hpatch_INewStreamListener* listener,size_t newPathIndex){
-    hpatch_BOOL  result=hpatch_TRUE;
-    TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
-    const char*  pathName=TNewDirOutput_getNewPathByIndex(self,newPathIndex);
-    check(pathName!=0);
-    if (hpatch_getIsDirName(pathName)){ //
-        check(self->_listener->makeNewDir(self->_listener,pathName));
-    }else{ //empty file
-        check(self->_listener->openNewFile(self->_listener,self->_curNewFile,pathName,0));
-        check(!self->_curNewFile->fileError);
-        check(self->_listener->closeNewFile(self->_listener,self->_curNewFile));
-    }
-clear:
-    return result;
-}
-
-static const char* _getOldPathByIndex(TNewDirOutput* self,size_t oldPathIndex){
-    assert(self->_oldPathListener.getOldPathByIndex!=0);
-    return self->_oldPathListener.getOldPathByIndex(&self->_oldPathListener,oldPathIndex);
-}
-
-static hpatch_BOOL _copySameFile(hpatch_INewStreamListener* listener,size_t newPathIndex,size_t oldPathIndex){
-    hpatch_BOOL  result=hpatch_TRUE;
-    TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
-    const char*  newFileName=0;
-    const char*  oldFileName=0;
-    assert(newPathIndex<self->newPathCount);
-    newFileName=TNewDirOutput_getNewPathByIndex(self,newPathIndex);
-    check(newFileName!=0);
-    check(self->_oldPathListener.getOldPathByIndex!=0);
-    oldFileName=_getOldPathByIndex(self,oldPathIndex);
-    check(oldFileName!=0);
-    check(self->_listener->copySameFile(self->_listener,oldFileName,newFileName,
-                                        self->isCheck_copyFileData?(&self->_sameFileCopyListener):0));
-clear:
-    return result;
-}
-
-static hpatch_BOOL _openNewFile(hpatch_INewStreamListener* listener,size_t newRefIndex,
-                                const hpatch_TStreamOutput** out_newFileStream){
-    hpatch_BOOL  result=hpatch_TRUE;
-    TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
-    const char*  utf8fileName=0;
-    hpatch_StreamPos_t fileSize=self->newRefSizeList[newRefIndex];
-    assert(newRefIndex<self->newRefFileCount);
-    assert(self->_curNewFile->m_file==0);
-    if (fileSize==0){
-        size_t newPathIndex=self->newRefList?self->newRefList[newRefIndex]:newRefIndex;
-        check(_makeNewDirOrEmptyFile(listener,newPathIndex));
-        *out_newFileStream=0;
-    }else{
-        utf8fileName=TNewDirOutput_getNewPathByRefIndex(self,newRefIndex);
-        check(utf8fileName!=0);
-        check(self->_listener->openNewFile(self->_listener,self->_curNewFile,
-                                           utf8fileName,fileSize));
-        *out_newFileStream=&self->_curNewFile->base;
-    }
-clear:
-    return result;
-}
-static hpatch_BOOL _closeNewFile(hpatch_INewStreamListener* listener,const hpatch_TStreamOutput* newFileStream){
-    hpatch_BOOL  result=hpatch_TRUE;
-    TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
-    assert(self->_curNewFile!=0);
-    assert(newFileStream==&self->_curNewFile->base);
-    check(!self->_curNewFile->fileError);
-    check(self->_listener->closeNewFile(self->_listener,self->_curNewFile));
-    hpatch_TFileStreamOutput_init(self->_curNewFile);
-clear:
-    return result;
-}
-
-static void _writedNewRefData(struct hpatch_INewStreamListener* listener,const unsigned char* data,
-                             const unsigned char* dataEnd){
-    TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
-    if (self->isCheck_newRefData)
-        self->_checksumPlugin->append(self->_newRefChecksumHandle,data,dataEnd);
-}
-
-static hpatch_BOOL _do_checksumEnd(TNewDirOutput* self,const TByte* checksumTest,TByte* checksumTemp,
-                                   hpatch_checksumHandle* pcsHandle){
-    size_t checksumByteSize=self->_checksumPlugin->checksumByteSize();
-    hpatch_checksumHandle* csHandle=*pcsHandle;
-    assert(csHandle!=0);
-    *pcsHandle=0;
-    self->_checksumPlugin->end(csHandle,checksumTemp,checksumTemp+checksumByteSize);
-    self->_checksumPlugin->close(self->_checksumPlugin,csHandle);
-    return (0==memcmp(checksumTest,checksumTemp,checksumByteSize));
-}
-
-#define _pchecksumNewRef(_self)     ((_self)->_pChecksum_newRefData_copyFileData)
-#define _pchecksumCopyFile(_self)   ((_self)->_pChecksum_newRefData_copyFileData+(_self)->checksumByteSize)
-#define _pchecksumTemp(_self)       ((_self)->_pChecksum_temp)
-
-static hpatch_BOOL _writedFinish(struct hpatch_INewStreamListener* listener){
-    hpatch_BOOL  result=hpatch_TRUE;
-    TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
-    //checksum newRefData end
-    if (self->isCheck_newRefData){
-        if (!_do_checksumEnd(self,_pchecksumNewRef(self),_pchecksumTemp(self),&self->_newRefChecksumHandle))
-            self->_isNewRefDataChecksumError=hpatch_TRUE;
-    }
-    //checksum sameFileData end
-    if (self->isCheck_copyFileData){
-        if (!_do_checksumEnd(self,_pchecksumCopyFile(self),_pchecksumTemp(self),&self->_sameFileChecksumHandle))
-            self->_isCopyDataChecksumError=hpatch_TRUE;
-    }
-    check(!self->_isNewRefDataChecksumError);
-    check(!self->_isCopyDataChecksumError);
-clear:
-    return result;
-}
-
-static void _sameFile_copyedData(hpatch_ICopyDataListener* listener,const unsigned char* data,
-                                 const unsigned char* dataEnd){
-    TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
-    if (self->isCheck_copyFileData)
-        self->_checksumPlugin->append(self->_sameFileChecksumHandle,data,dataEnd);
-}
-
-hpatch_BOOL TNewDirOutput_openDir(TNewDirOutput* self,IDirPatchListener* listener,
-                                  size_t kAlignSize,const hpatch_TStreamOutput** out_newDirStream){
-    hpatch_BOOL result=hpatch_TRUE;
-    size_t      refCount=self->newRefFileCount;
-    assert(self->_pmem==0);
-    assert(self->_newDirStream.stream==0);
-    assert(self->_newDirStreamListener.listenerImport==0);
-    self->_listener=listener;
-    {//open new
-        size_t      memSize=sizeof(hpatch_TFileStreamOutput);
-        self->_pmem=malloc(memSize);
-        check(self->_pmem!=0);
-        self->_curNewFile=(hpatch_TFileStreamOutput*)self->_pmem;
-        hpatch_TFileStreamOutput_init(self->_curNewFile);
-        
-        self->_newDirStreamListener.listenerImport=self;
-        self->_newDirStreamListener.makeNewDirOrEmptyFile=_makeNewDirOrEmptyFile;
-        self->_newDirStreamListener.copySameFile=_copySameFile;
-        self->_newDirStreamListener.openNewFile=_openNewFile;
-        self->_newDirStreamListener.closeNewFile=_closeNewFile;
-        self->_newDirStreamListener.writedNewRefData=_writedNewRefData;
-        self->_newDirStreamListener.writedFinish=_writedFinish;
-    }
-    //checksum newRefData begin
-    if (self->isCheck_newRefData){
-        assert(self->_newRefChecksumHandle==0);
-        self->_newRefChecksumHandle=self->_checksumPlugin->open(self->_checksumPlugin);
-        check(self->_newRefChecksumHandle!=0);
-        self->_checksumPlugin->begin(self->_newRefChecksumHandle);
-    }
-    //checksum sameFileData begin
-    if (self->isCheck_copyFileData){
-        assert(self->_sameFileChecksumHandle==0);
-        self->_sameFileChecksumHandle=self->_checksumPlugin->open(self->_checksumPlugin);
-        check(self->_sameFileChecksumHandle!=0);
-        self->_checksumPlugin->begin(self->_sameFileChecksumHandle);
-        
-        if (self->isCheck_copyFileData){
-            self->_sameFileCopyListener.listenerImport=self;
-            self->_sameFileCopyListener.copyedData=_sameFile_copyedData;
-        }
-    }
-    check(hpatch_TNewStream_open(&self->_newDirStream,&self->_newDirStreamListener,
-                                 self->newDataSize,self->newPathCount,
-                                 self->newRefList,refCount,self->dataSamePairList,
-                                 self->sameFilePairCount,kAlignSize));
-    *out_newDirStream=self->_newDirStream.stream;
-clear:
-    return result;
-}
-
-
-hpatch_BOOL TNewDirOutput_closeNewDirHandles(TNewDirOutput* self){
-    hpatch_BOOL result=hpatch_TNewStream_closeFileHandles(&self->_newDirStream);
-    if (self->_curNewFile){
-        if (!hpatch_TFileStreamOutput_close(self->_curNewFile))
-            result=hpatch_FALSE;
-        hpatch_TFileStreamOutput_init(self->_curNewFile);
-    }
-    return result;
-}
-
-hpatch_BOOL TNewDirOutput_close(TNewDirOutput* self){
-    hpatch_BOOL result=TNewDirOutput_closeNewDirHandles(self);
-    hpatch_TChecksum* checksumPlugin=self->_checksumPlugin;
-    if (!hpatch_TNewStream_close(&self->_newDirStream))
-        result=hpatch_FALSE;
-    self->_newRootDir=0;
-    self->_newRootDir_end=0;
-    self->_newRootDir_bufEnd=0;
-    self->_curNewFile=0;
-    if (self->_newRefChecksumHandle){
-        checksumPlugin->close(checksumPlugin,self->_newRefChecksumHandle);
-        self->_newRefChecksumHandle=0;
-    }
-    if (self->_sameFileChecksumHandle){
-        checksumPlugin->close(checksumPlugin,self->_sameFileChecksumHandle);
-        self->_sameFileChecksumHandle=0;
-    }
-    if (self->_pmem) {
-        free(self->_pmem);
-        self->_pmem=0;
-    }
-    return result;
-}
-
-const char* TNewDirOutput_getNewPathRoot(TNewDirOutput* self){
-    if (!setPath(self->_newRootDir_end,self->_newRootDir_bufEnd,"")) return 0; //error
-    return self->_newRootDir;
-}
-
-const char* TNewDirOutput_getNewPathByIndex(TNewDirOutput* self,size_t newPathIndex){
-    assert(newPathIndex<self->newPathCount);
-    if (!setPath(self->_newRootDir_end,self->_newRootDir_bufEnd,
-                 self->newUtf8PathList[newPathIndex])) return 0; //error
-    return self->_newRootDir;
-}
-
-const char* TNewDirOutput_getNewPathByRefIndex(TNewDirOutput* self,size_t newRefIndex){
-    size_t newPathIndex;
-    assert(newRefIndex<self->newRefFileCount);
-    newPathIndex=self->newRefList?self->newRefList[newRefIndex]:newRefIndex;
-    return TNewDirOutput_getNewPathByIndex(self,newPathIndex);
-}
-
-const char* TNewDirOutput_getNewExecuteFileByIndex(TNewDirOutput* self,size_t newExecuteIndex){
-    assert(newExecuteIndex<self->newExecuteCount);
-    return TNewDirOutput_getNewPathByIndex(self,self->newExecuteList[newExecuteIndex]);
-}
-
-const char* TNewDirOutput_getOldPathBySameIndex(TNewDirOutput* self,size_t sameIndex){
-    assert(sameIndex<self->sameFilePairCount);
-    assert(self->dataSamePairList!=0);
-    return _getOldPathByIndex(self,self->dataSamePairList[sameIndex].oldIndex);
-}
-
-const char* TNewDirOutput_getNewPathBySameIndex(TNewDirOutput* self,size_t sameIndex){
-    assert(sameIndex<self->sameFilePairCount);
-    assert(self->dataSamePairList!=0);
-    return TNewDirOutput_getNewPathByIndex(self,self->dataSamePairList[sameIndex].newIndex);
-}
-
-#endif

package/harmony/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/new_dir_output.h

@@ -1,144 +0,0 @@
-// new_dir_output.h
-// hdiffz dir patch
-//
-/*
- The MIT License (MIT)
- Copyright (c) 2018-2019 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 DirPatch_new_dir_output_h
-#define DirPatch_new_dir_output_h
-#include "dir_patch_types.h"
-#if (_IS_NEED_DIR_DIFF_PATCH)
-#include "../../libHDiffPatch/HPatch/checksum_plugin.h"
-#include "ref_stream.h"
-#include "new_stream.h"
-#include "res_handle_limit.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-    
-    typedef struct hpatch_ICopyDataListener{
-        void* listenerImport;
-        void    (*copyedData)(struct hpatch_ICopyDataListener* listener,const unsigned char* data,
-                              const unsigned char* dataEnd);
-    } hpatch_ICopyDataListener;
-    
-hpatch_BOOL TDirPatcher_copyFile(const char* oldFileName_utf8,const char* newFileName_utf8,
-                                 hpatch_ICopyDataListener* copyListener);
-hpatch_BOOL TDirPatcher_readFile(const char* oldFileName_utf8,hpatch_ICopyDataListener* copyListener);
-
-
-    struct hpatch_TFileStreamOutput;
-    
-    typedef struct IDirPatchListener{
-        void*       listenerImport;
-        hpatch_BOOL   (*makeNewDir)(struct IDirPatchListener* listener,const char* newDir);
-        hpatch_BOOL (*copySameFile)(struct IDirPatchListener* listener,const char* oldFileName,
-                                    const char* newFileName,hpatch_ICopyDataListener* copyListener);
-        hpatch_BOOL  (*openNewFile)(struct IDirPatchListener* listener,struct hpatch_TFileStreamOutput*  out_curNewFile,
-                                    const char* newFileName,hpatch_StreamPos_t newFileSize);
-        hpatch_BOOL (*closeNewFile)(struct IDirPatchListener* listener,struct hpatch_TFileStreamOutput* curNewFile);
-    } IDirPatchListener;
-    
-    
-    typedef struct hpatch_IOldPathListener{
-        void* listenerImport;
-        const char* (*getOldPathByIndex)(struct hpatch_IOldPathListener* listener,size_t oldPathIndex);
-    } hpatch_IOldPathListener;
-    
-    typedef struct TNewDirOutput{
-        //input:
-        const char* const *         newUtf8PathList;
-        const size_t*               newRefList;
-        const size_t*               newExecuteList;
-        const hpatch_StreamPos_t*   newRefSizeList;
-        const hpatch_TSameFilePair* dataSamePairList; //new map to old index
-        hpatch_StreamPos_t          newDataSize;
-        size_t                      newPathCount;
-        size_t                      newRefFileCount;
-        size_t                      newExecuteCount;
-        size_t                      sameFilePairCount;
-        size_t                      checksumByteSize;
-        hpatch_BOOL                 isCheck_newRefData;
-        hpatch_BOOL                 isCheck_copyFileData;
-        //private input:
-        hpatch_IOldPathListener     _oldPathListener;
-        char*                       _newRootDir;
-        char*                       _newRootDir_end;
-        char*                       _newRootDir_bufEnd;
-        const unsigned char*        _pChecksum_newRefData_copyFileData;
-        unsigned char*              _pChecksum_temp;
-        hpatch_TChecksum*           _checksumPlugin;
-        //private:
-        hpatch_ICopyDataListener    _sameFileCopyListener;
-        hpatch_TNewStream           _newDirStream;
-        IDirPatchListener*          _listener;
-        hpatch_INewStreamListener   _newDirStreamListener;
-        hpatch_checksumHandle       _newRefChecksumHandle;
-        hpatch_checksumHandle       _sameFileChecksumHandle;
-        hpatch_BOOL                 _isNewRefDataChecksumError;
-        hpatch_BOOL                 _isCopyDataChecksumError;
-        struct hpatch_TFileStreamOutput*   _curNewFile;
-        void*                       _pmem;
-    } TNewDirOutput;
-
-hpatch_inline
-static void TNewDirOutput_init(TNewDirOutput* self)  { memset(self,0,sizeof(*self)); }
-hpatch_BOOL TNewDirOutput_openDir(TNewDirOutput* self,IDirPatchListener* listener,
-                                  size_t kAlignSize,const hpatch_TStreamOutput** out_newDirStream);
-
-hpatch_BOOL TNewDirOutput_closeNewDirHandles(TNewDirOutput* self);//for TNewDirOutput_openDir
-hpatch_BOOL TNewDirOutput_close(TNewDirOutput* self);
-
-const char* TNewDirOutput_getNewPathRoot(TNewDirOutput* self);
-const char* TNewDirOutput_getNewPathByIndex(TNewDirOutput* self,size_t newPathIndex);
-const char* TNewDirOutput_getNewExecuteFileByIndex(TNewDirOutput* self,size_t newExecuteIndex);
-const char* TNewDirOutput_getNewPathByRefIndex(TNewDirOutput* self,size_t newRefIndex);
-const char* TNewDirOutput_getOldPathBySameIndex(TNewDirOutput* self,size_t sameIndex);
-const char* TNewDirOutput_getNewPathBySameIndex(TNewDirOutput* self,size_t sameIndex);
-
-//ExecuteList
-typedef const char* (*IDirPathList_getPathNameByIndex)(void* import,size_t index);
-typedef struct IDirPathList{
-    void*                   import;
-    size_t                  pathCount;
-    IDirPathList_getPathNameByIndex getPathNameByIndex;
-} IDirPathList;
-
-static hpatch_inline void TNewDirOutput_getExecuteList(TNewDirOutput* self,IDirPathList* out_executeList) {
-    out_executeList->import=self;
-    out_executeList->pathCount=self->newExecuteCount;
-    out_executeList->getPathNameByIndex=(IDirPathList_getPathNameByIndex)TNewDirOutput_getNewExecuteFileByIndex;
-}
-static hpatch_inline void TNewDirOutput_getNewDirPathList(TNewDirOutput* self,IDirPathList* out_newPathList) {
-    out_newPathList->import=self;
-    out_newPathList->pathCount=self->newPathCount;
-    out_newPathList->getPathNameByIndex=(IDirPathList_getPathNameByIndex)TNewDirOutput_getNewPathByIndex;
-}
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-#endif //DirPatch_new_dir_output_h

package/harmony/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/new_stream.c

@@ -1,176 +0,0 @@
-//  new_stream.cpp
-//  dir patch
-/*
- The MIT License (MIT)
- Copyright (c) 2018-2019 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 "new_stream.h"
-#if (_IS_NEED_DIR_DIFF_PATCH)
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h> //printf
-
-
-hpatch_BOOL hpatch_TNewStream_closeFileHandles(hpatch_TNewStream* self){
-    hpatch_BOOL result=hpatch_TRUE;
-    const hpatch_TStreamOutput* curNewFile=self->_curNewFile;
-    if (curNewFile){
-        self->_curNewFile=0;
-        result=self->_listener->closeNewFile(self->_listener,curNewFile);
-    }
-    return result;
-}
-
-hpatch_BOOL hpatch_TNewStream_close(hpatch_TNewStream* self){
-    return hpatch_TNewStream_closeFileHandles(self);
-}
-
-static hpatch_BOOL _file_entry_end(hpatch_TNewStream* self);
-static hpatch_BOOL _file_append_ready(hpatch_TNewStream* self);
-static hpatch_BOOL _file_append_part(hpatch_TNewStream* self,hpatch_StreamPos_t writeToPos,
-                                     const unsigned char* data,const unsigned char* data_end);
-static hpatch_BOOL _file_append_end(hpatch_TNewStream* self);
-
-#define  check(value) { if (!(value)){ fprintf(stderr,"check "#value" error!\n"); return hpatch_FALSE; } }
-
-static hpatch_BOOL _TNewStream_write(const hpatch_TStreamOutput* stream,hpatch_StreamPos_t writeToPos,
-                                     const unsigned char* data,const unsigned char* data_end){
-    hpatch_TNewStream* self=(hpatch_TNewStream*)stream->streamImport;
-    self->_listener->writedNewRefData(self->_listener,data,data_end);
-    while (data!=data_end) {
-        size_t writeLen=(size_t)(data_end-data);
-        check(!self->isFinish);
-        check(writeToPos<self->_curWriteToPosEnd);
-        if (writeToPos+writeLen>self->_curWriteToPosEnd)
-            writeLen=(size_t)(self->_curWriteToPosEnd-writeToPos);
-        check(self->_curPathIndex<self->_pathCount);
-        check(_file_append_part(self,writeToPos,data,data+writeLen));
-        data+=writeLen;
-        writeToPos+=writeLen;
-        
-        if (writeToPos==self->_curWriteToPosEnd){//write one file end?
-            check(_file_append_end(self));
-            ++self->_curPathIndex;
-            check(_file_append_ready(self));
-        }
-    }
-    return hpatch_TRUE;
-}
-
-static hpatch_BOOL _file_append_ready(hpatch_TNewStream* self){
-    assert(self->_curNewFile==0);
-    assert(self->_curWriteToPos==self->_curWriteToPosEnd);
-    while (self->_curPathIndex<self->_pathCount) {
-        if((self->_curNewRefIndex<self->_newRefCount) //write file ?
-           &&(self->_curPathIndex==(self->_newRefList?self->_newRefList[self->_curNewRefIndex]
-                                    :self->_curNewRefIndex))){
-            check(self->_listener->openNewFile(self->_listener,self->_curNewRefIndex,&self->_curNewFile));
-            ++self->_curNewRefIndex;
-            if (self->_curNewFile){//new file
-                self->_curWriteToPosEnd+=toAlignRangeSize(self->_curNewFile->streamSize,self->kAlignSize);
-                return hpatch_TRUE;
-            }else{ //make dir or empty file
-                ++self->_curPathIndex;
-            }
-        }else if ((self->_curSamePairIndex<self->_samePairCount) //copy file ?
-            &&(self->_curPathIndex==self->_samePairList[self->_curSamePairIndex].newIndex)){
-            const hpatch_TSameFilePair* pair=self->_samePairList+self->_curSamePairIndex;
-            check(self->_listener->copySameFile(self->_listener,pair->newIndex,pair->oldIndex));
-            ++self->_curSamePairIndex;
-            ++self->_curPathIndex;
-        }else{ //make dir or empty file
-            check(self->_listener->makeNewDirOrEmptyFile(self->_listener,self->_curPathIndex));
-            ++self->_curPathIndex;
-        }
-    }
-    //file entry end
-    check(_file_entry_end(self));
-    return hpatch_TRUE;
-}
-
-static hpatch_BOOL _file_append_part(hpatch_TNewStream* self,hpatch_StreamPos_t g_writeToPos,
-                                     const unsigned char* data,const unsigned char* data_end){
-    hpatch_StreamPos_t curFilePos;
-    hpatch_StreamPos_t alignRangeSize;
-    assert(self->_curNewFile!=0);
-    assert((g_writeToPos<=self->_curWriteToPosEnd)&&(g_writeToPos==self->_curWriteToPos));
-    alignRangeSize=toAlignRangeSize(self->_curNewFile->streamSize,self->kAlignSize);
-    curFilePos=g_writeToPos-(self->_curWriteToPosEnd-alignRangeSize);
-    self->_curWriteToPos=g_writeToPos+(size_t)(data_end-data);
-    if (curFilePos>=self->_curNewFile->streamSize)
-        return hpatch_TRUE;
-    if (curFilePos+(size_t)(data_end-data)>self->_curNewFile->streamSize)
-        data_end=data+(size_t)(self->_curNewFile->streamSize-curFilePos);
-    return self->_curNewFile->write(self->_curNewFile,curFilePos,data,data_end);
-}
-
-static hpatch_BOOL _file_append_end(hpatch_TNewStream* self){
-    const hpatch_TStreamOutput* curNewFile=self->_curNewFile;
-    assert(curNewFile!=0);
-    assert(self->_curWriteToPos==self->_curWriteToPosEnd);
-    self->_curNewFile=0;
-    return self->_listener->closeNewFile(self->_listener,curNewFile);
-}
-
-static hpatch_BOOL _file_entry_end(hpatch_TNewStream* self){
-    check(!self->isFinish);
-    check(self->_curPathIndex==self->_pathCount);
-    check(self->_curSamePairIndex==self->_samePairCount);
-    self->isFinish=hpatch_TRUE;
-    check(self->_listener->writedFinish(self->_listener));
-    return hpatch_TRUE;
-}
-
-hpatch_BOOL hpatch_TNewStream_open(hpatch_TNewStream* self,hpatch_INewStreamListener* listener,
-                                   hpatch_StreamPos_t newRefDataSize, size_t newPathCount,
-                                   const size_t* newRefList,size_t newRefCount,
-                                   const hpatch_TSameFilePair* samePairList,size_t samePairCount,
-                                   size_t kAlignSize){
-    assert(self->_listener==0);
-    assert(self->stream==0);
-    assert(self->_curNewFile==0);
-    self->_listener=listener;
-    self->isFinish=hpatch_FALSE;
-    self->kAlignSize=kAlignSize;
-    self->_pathCount=newPathCount;
-    self->_newRefList=newRefList;
-    self->_newRefCount=newRefCount;
-    self->_samePairList=samePairList;
-    self->_samePairCount=samePairCount;
-    
-    self->_stream.streamImport=self;
-    self->_stream.streamSize=newRefDataSize;
-    self->_stream.read_writed=0;
-    self->_stream.write=_TNewStream_write;
-    self->stream=&self->_stream;
-    
-    self->_curPathIndex=0;
-    self->_curWriteToPos=0;
-    self->_curWriteToPosEnd=0;
-    self->_curNewRefIndex=0;
-    self->_curSamePairIndex=0;
-    return _file_append_ready(self);
-}
-
-#endif