react-native-update 10.34.2 → 10.34.3

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/new_stream.h

@@ -0,0 +1,84 @@
+//  new_stream.h
+//  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_stream_h
+#define DirPatch_new_stream_h
+#include "dir_patch_types.h"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+
+typedef struct hpatch_INewStreamListener{
+    void*       listenerImport;
+    hpatch_BOOL (*makeNewDirOrEmptyFile)(struct hpatch_INewStreamListener* listener,size_t newPathIndex);
+    hpatch_BOOL (*copySameFile)(struct hpatch_INewStreamListener* listener,size_t newPathIndex,size_t oldPathIndex);
+    hpatch_BOOL  (*openNewFile)(struct hpatch_INewStreamListener* listener,size_t newRefIndex,
+                                const hpatch_TStreamOutput** out_newFileStream);
+    hpatch_BOOL (*closeNewFile)(struct hpatch_INewStreamListener* listener,const hpatch_TStreamOutput* newFileStream);
+    void    (*writedNewRefData)(struct hpatch_INewStreamListener* listener,const unsigned char* data,
+                                const unsigned char* dataEnd);
+    hpatch_BOOL (*writedFinish)(struct hpatch_INewStreamListener* listener);
+} hpatch_INewStreamListener;
+
+typedef struct hpatch_TSameFilePair{
+    size_t  newIndex;
+    size_t  oldIndex;
+} hpatch_TSameFilePair;
+
+//externally simulates an output stream;
+//Generate new files and copy files using samePairList, newRefList, etc.
+typedef struct hpatch_TNewStream{
+    const hpatch_TStreamOutput* stream;
+    hpatch_BOOL             isFinish;
+//private:
+    size_t                  kAlignSize;
+    size_t                  _pathCount;
+    const size_t*           _newRefList;
+    size_t                  _newRefCount;
+    const hpatch_TSameFilePair* _samePairList;
+    size_t                  _samePairCount;
+    hpatch_TStreamOutput    _stream;
+    
+    size_t                  _curPathIndex;
+    size_t                  _curNewRefIndex;
+    size_t                  _curSamePairIndex;
+    hpatch_StreamPos_t      _curWriteToPos;
+    hpatch_StreamPos_t      _curWriteToPosEnd;
+    const hpatch_TStreamOutput* _curNewFile;
+    hpatch_INewStreamListener*  _listener;
+} hpatch_TNewStream;
+
+hpatch_inline static
+void        hpatch_TNewStream_init(hpatch_TNewStream* self) { memset(self,0,sizeof(*self)); }
+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);
+hpatch_BOOL hpatch_TNewStream_closeFileHandles(hpatch_TNewStream* self);
+hpatch_BOOL hpatch_TNewStream_close(hpatch_TNewStream* self);
+
+#endif
+#endif

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/ref_stream.c

@@ -0,0 +1,146 @@
+//  ref_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 "ref_stream.h"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#include <stdio.h>
+#include <stdlib.h>
+
+void hpatch_TRefStream_close(hpatch_TRefStream* self){
+    if (self->_buf) { free(self->_buf); self->_buf=0; }
+}
+
+#define  check(value) { if (!(value)){ LOG_ERR("check "#value" error!\n");  \
+                                       result=hpatch_FALSE; goto clear; } }
+
+static hpatch_BOOL _TRefStream_read_do(hpatch_TRefStream* self,hpatch_StreamPos_t readFromPos,
+                               unsigned char* out_data,unsigned char* out_data_end,size_t curRangeIndex){
+    hpatch_StreamPos_t readPos=readFromPos - self->_rangeEndList[curRangeIndex-1];
+    //[0                streamSize]
+    //     ^
+    //     [readPos                    ]
+    const hpatch_TStreamInput* ref=self->_refList[curRangeIndex];
+    size_t needOutSize=out_data_end-out_data;
+    if (readPos>=ref->streamSize){
+        memset(out_data,0,needOutSize);
+        return hpatch_TRUE;
+    }
+    if (readPos+needOutSize>ref->streamSize){
+        memset(out_data+(ref->streamSize-readPos),0,(size_t)((readPos+needOutSize)-ref->streamSize));
+        needOutSize=(size_t)(ref->streamSize-readPos);
+    }
+    return ref->read(ref,readPos,out_data,out_data+needOutSize);
+}
+
+static size_t findRangeIndex(const hpatch_StreamPos_t* ranges,size_t rangeCount,hpatch_StreamPos_t pos){
+    //not find return rangeCount
+    //optimize, binary search?
+    size_t i;
+    for (i=0; i<rangeCount; ++i) {
+        if (pos>=ranges[i]) continue;
+        return i;
+    }
+    return rangeCount;
+}
+
+static hpatch_BOOL _refStream_read(const hpatch_TStreamInput* stream,
+                                   hpatch_StreamPos_t readFromPos,
+                                   unsigned char* out_data,unsigned char* out_data_end){
+    hpatch_BOOL  result=hpatch_TRUE;
+    hpatch_TRefStream* self=(hpatch_TRefStream*)stream->streamImport;
+    const hpatch_StreamPos_t* ranges=self->_rangeEndList;
+    size_t curRangeIndex=self->_curRangeIndex;
+    while (out_data<out_data_end) {
+        size_t readLen=(out_data_end-out_data);
+        if (ranges[curRangeIndex-1]<=readFromPos){ //-1 safe
+            if (readFromPos+readLen<=ranges[curRangeIndex]){//hit all
+                check(_TRefStream_read_do(self,readFromPos,out_data,out_data_end,curRangeIndex));
+                break; //ok out while
+            }else if (readFromPos<=ranges[curRangeIndex]){//hit left
+                hpatch_StreamPos_t leftLen=(ranges[curRangeIndex]-readFromPos);
+                if (leftLen>0)
+                    check(_TRefStream_read_do(self,readFromPos,out_data,out_data+leftLen,curRangeIndex));
+                ++curRangeIndex;
+                readFromPos+=leftLen;
+                out_data+=leftLen;
+                continue; //next
+            }//else
+        }//else
+        
+        curRangeIndex=findRangeIndex(ranges,self->_rangeCount,readFromPos);
+        check(curRangeIndex<self->_rangeCount);
+    }
+    self->_curRangeIndex=curRangeIndex;
+clear:
+    return result;
+}
+
+hpatch_BOOL _createRange(hpatch_TRefStream* self,const hpatch_TStreamInput** refList,
+                         size_t refCount,size_t kAlignSize){
+    hpatch_BOOL result=hpatch_TRUE;
+    size_t   i;
+    size_t   rangIndex=0;
+    hpatch_StreamPos_t curSumSize=0;
+    assert(self->_buf==0);
+    assert(self->_refList==0);
+    assert(kAlignSize>0);
+    
+    self->_refList=refList;
+    self->_rangeCount=refCount;
+    self->_buf=malloc(sizeof(hpatch_StreamPos_t)*(self->_rangeCount+1));
+    check(self->_buf!=0);
+    self->_rangeEndList=((hpatch_StreamPos_t*)self->_buf)+1; //+1 for _rangeEndList[-1] safe
+    self->_rangeEndList[-1]=0;
+    for (i=0; i<refCount; ++i) {
+        hpatch_StreamPos_t rangeSize=refList[i]->streamSize;
+        rangeSize=toAlignRangeSize(rangeSize,kAlignSize);
+        curSumSize+=rangeSize;
+        self->_rangeEndList[rangIndex]=curSumSize;
+        ++rangIndex;
+    }
+    assert(rangIndex==self->_rangeCount);
+    self->_curRangeIndex=0;
+clear:
+    return result;
+}
+
+hpatch_BOOL hpatch_TRefStream_open(hpatch_TRefStream* self,const hpatch_TStreamInput** refList,
+                                   size_t refCount,size_t kAlignSize){ //kAlignSize default 1
+    hpatch_BOOL result=hpatch_TRUE;
+    check(self->stream==0);
+    check(_createRange(self,refList,refCount,kAlignSize));
+    
+    self->kAlignSize=kAlignSize;
+    self->_stream.streamImport=self;
+    self->_stream.streamSize=self->_rangeEndList[self->_rangeCount-1]; //safe
+    self->_stream.read=_refStream_read;
+    self->stream=&self->_stream;
+clear:
+    return result;
+}
+
+#endif

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/ref_stream.h

@@ -0,0 +1,61 @@
+//  ref_stream.h
+//  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_ref_stream_h
+#define DirPatch_ref_stream_h
+#include "dir_patch_types.h"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+//Simulate an input stream using refList;
+typedef struct hpatch_TRefStream{
+    const hpatch_TStreamInput*  stream;
+//private:
+    hpatch_TStreamInput         _stream;
+    
+    const hpatch_TStreamInput** _refList;
+    hpatch_StreamPos_t*         _rangeEndList;
+    size_t                      _rangeCount;//==refCount
+    size_t                      _curRangeIndex;
+    size_t                      kAlignSize;
+    //mem
+    void*                       _buf;
+} hpatch_TRefStream;
+
+hpatch_inline static
+void        hpatch_TRefStream_init(hpatch_TRefStream* self) { memset(self,0,sizeof(*self)); }
+hpatch_BOOL hpatch_TRefStream_open(hpatch_TRefStream* self,const hpatch_TStreamInput** refList,
+                                   size_t refCount,size_t kAlignSize);
+void        hpatch_TRefStream_close(hpatch_TRefStream* self);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+#endif //DirPatch_ref_stream_h

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/res_handle_limit.c

@@ -0,0 +1,152 @@
+//  res_handle_limit.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 "res_handle_limit.h"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#include <stdio.h>
+#include <stdlib.h>
+
+#define  check(value) { if (!(value)){ LOG_ERR("check "#value" error!\n"); return hpatch_FALSE; } }
+
+static hpatch_BOOL _TResHandleLimit_closeOneHandle(hpatch_TResHandleLimit* self){
+    size_t              best_i=~(size_t)0;
+    hpatch_StreamPos_t  best_hit=~(hpatch_StreamPos_t)0;
+    hpatch_TStreamInput*    cur=0;
+    hpatch_IResHandle*      res=0;
+    size_t count=self->streamCount;
+    size_t i;
+    for (i=0; i<count;++i) {
+        if (self->_in_streamList[i]){
+            hpatch_StreamPos_t cur_hit=self->_ex_streamList[i].hit;
+            if (cur_hit<best_hit){
+                best_hit=cur_hit;
+                best_i=i;
+            }
+        }
+    }
+    check(best_i<count);
+    cur=self->_in_streamList[best_i];
+    res=&self->_resList[best_i];
+    self->_in_streamList[best_i]=0;
+    check(res->close(res,cur));
+    --self->_curOpenCount;
+    return hpatch_TRUE;
+}
+
+static hpatch_BOOL _TResHandleLimit_openHandle(hpatch_TResHandleLimit* self,size_t index){
+    hpatch_IResHandle*  res=&self->_resList[index];
+    hpatch_TStreamInput** pCur=&self->_in_streamList[index];
+    assert((*pCur)==0);
+    if (self->_curOpenCount>=self->_limitMaxOpenCount)
+        check(_TResHandleLimit_closeOneHandle(self));
+    check(res->open(res,pCur));
+    check((*pCur)!=0);
+    check((*pCur)->streamSize==res->resStreamSize);
+    ++self->_curOpenCount;
+    return hpatch_TRUE;
+}
+
+static hpatch_BOOL _TResHandleLimit_read(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                                         unsigned char* out_data,unsigned char* out_data_end){
+    _hpatch_TResHandleBox*  ex=(_hpatch_TResHandleBox*)stream->streamImport;
+    hpatch_TResHandleLimit* self=ex->owner;
+    size_t           index=ex-self->_ex_streamList;
+    const hpatch_TStreamInput* in_stream=self->_in_streamList[index];
+    assert(index<self->streamCount);
+    ex->hit= ++self->_curHit;
+    if (!in_stream){
+        check(_TResHandleLimit_openHandle(self,index));
+        in_stream=self->_in_streamList[index];
+    }
+    return in_stream->read(in_stream,readFromPos,out_data,out_data_end);
+}
+
+hpatch_BOOL hpatch_TResHandleLimit_open(hpatch_TResHandleLimit* self,size_t limitMaxOpenCount,
+                                        hpatch_IResHandle* resList,size_t resCount){
+    unsigned char* curMem=0;
+    size_t i=0;
+    size_t memSize=resCount*(sizeof(const hpatch_TStreamInput*)
+                             +sizeof(hpatch_TStreamInput*)+sizeof(_hpatch_TResHandleBox));
+    assert(self->_buf==0);
+    if (limitMaxOpenCount<1) limitMaxOpenCount=1;
+    self->_buf=malloc(memSize);
+    if (self->_buf==0) return hpatch_FALSE;
+    curMem=self->_buf;
+    self->streamList=(const hpatch_TStreamInput**)curMem;
+        curMem+=resCount*sizeof(const hpatch_TStreamInput*);
+    self->_in_streamList=(hpatch_TStreamInput**)curMem;
+        curMem+=resCount*sizeof(hpatch_TStreamInput*);
+    self->_ex_streamList=(_hpatch_TResHandleBox*)curMem;
+        //curMem+=resCount*sizeof(_TResHandleBox);
+    self->streamCount=resCount;
+    self->_resList=resList;
+    self->_limitMaxOpenCount=limitMaxOpenCount;
+    self->_curHit=0;
+    self->_curOpenCount=0;
+    for (i=0; i<resCount; ++i) {
+        _hpatch_TResHandleBox* ex=&self->_ex_streamList[i];
+        ex->hit=0;
+        ex->owner=self;
+        ex->box.streamImport=ex;
+        ex->box.streamSize=self->_resList[i].resStreamSize;
+        ex->box.read=_TResHandleLimit_read;
+        
+        self->_in_streamList[i]=0;
+        self->streamList[i]=&self->_ex_streamList[i].box;
+    }
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL hpatch_TResHandleLimit_closeFileHandles(hpatch_TResHandleLimit* self){
+    size_t count=self->streamCount;
+    hpatch_BOOL result=hpatch_TRUE;
+    size_t i;
+    for (i=0; i<count; ++i) {
+        const hpatch_TStreamInput* stream=self->_in_streamList[i];
+        if (stream){
+            hpatch_IResHandle* res=&self->_resList[i];
+            if (!res->close(res,stream)) result=hpatch_FALSE;
+            self->_in_streamList[i]=0;
+            --self->_curOpenCount;
+        }
+    }
+    assert(self->_curOpenCount==0);
+    return result;
+}
+
+hpatch_BOOL hpatch_TResHandleLimit_close(hpatch_TResHandleLimit* self){
+    hpatch_BOOL result=hpatch_TResHandleLimit_closeFileHandles(self);
+    self->streamList=0;
+    self->streamCount=0;
+    if (self->_buf){
+        free(self->_buf);
+        self->_buf=0;
+    }
+    return result;
+}
+
+#endif

package/harmony/pushy/src/main/cpp/HDiffPatch/dirDiffPatch/dir_patch/res_handle_limit.h

@@ -0,0 +1,76 @@
+//  res_handle_limit.h
+//  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_res_handle_limit_h
+#define DirPatch_res_handle_limit_h
+#include "dir_patch_types.h"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct hpatch_IResHandle{
+    void*               resImport;
+    hpatch_StreamPos_t  resStreamSize;
+    hpatch_BOOL  (*open)(struct hpatch_IResHandle* self,hpatch_TStreamInput** out_stream);
+    hpatch_BOOL (*close)(struct hpatch_IResHandle* self,const hpatch_TStreamInput* stream);
+} hpatch_IResHandle;
+    
+struct hpatch_TResHandleLimit;
+typedef struct _hpatch_TResHandleBox{
+    hpatch_TStreamInput     box;
+    struct hpatch_TResHandleLimit* owner;
+    hpatch_StreamPos_t      hit;
+} _hpatch_TResHandleBox;
+
+//Internally controls the maximum number of simultaneously open handles, externally simulates a complete stream list where all resources are available;
+typedef struct hpatch_TResHandleLimit{
+    const hpatch_TStreamInput** streamList;
+    size_t                      streamCount;
+//private:
+    _hpatch_TResHandleBox*      _ex_streamList;
+    hpatch_TStreamInput**       _in_streamList;
+    hpatch_IResHandle*          _resList;
+    hpatch_StreamPos_t          _curHit;
+    size_t                      _curOpenCount;
+    size_t                      _limitMaxOpenCount;
+    //mem
+    unsigned char*              _buf;
+} hpatch_TResHandleLimit;
+
+hpatch_inline static
+void        hpatch_TResHandleLimit_init(hpatch_TResHandleLimit* self) { memset(self,0,sizeof(*self)); }
+hpatch_BOOL hpatch_TResHandleLimit_open(hpatch_TResHandleLimit* self,size_t limitMaxOpenCount,
+                                        hpatch_IResHandle* resList,size_t resCount);
+hpatch_BOOL hpatch_TResHandleLimit_closeFileHandles(hpatch_TResHandleLimit* self);
+hpatch_BOOL hpatch_TResHandleLimit_close(hpatch_TResHandleLimit* self);
+    
+#ifdef __cplusplus
+}
+#endif
+#endif
+#endif //DirPatch_res_handle_limit_h