src/Git/gittype.h

   1 #pragma once
   2 #include "GitHash.h"
   3
   4 enum
   5 {
   6         GIT_SUCCESS=0,
   7         GIT_ERROR_OPEN_PIP,
   8         GIT_ERROR_CREATE_PROCESS,
   9         GIT_ERROR_GET_EXIT_CODE
  10 };
  11
  12 extern BOOL g_IsWingitDllload;
  13
  14 class CGitByteArray:public std::vector<BYTE>
  15 {
  16 public:
  17         CGitByteArray(){ m_critSec.Init(); }
  18         CComCriticalSection                     m_critSec;
  19
  20         int find(BYTE data,int start=0)
  21         {
  22                 for(int i=start;i<size();i++)
  23                         if( at(i) == data )
  24                                 return i;
  25                 return -1;
  26         }
  27         int RevertFind(BYTE data, int start=-1)
  28         {
  29                 if(start == -1)
  30                         start=size()-1;
  31
  32                 if(start<0)
  33                         return -1;
  34
  35                 for(int i=start; i>=0;i--)
  36                         if( at(i) == data )
  37                                 return i;
  38                 return -1;
  39         }
  40         int findNextString(int start=0)
  41         {
  42                 int pos=start;
  43                 do
  44                 {
  45                         pos=find(0,pos);
  46                         if(pos >= 0)
  47                                 pos++;
  48                         else
  49                                 break;
  50
  51                         if( pos >= size())
  52                                 return -1;
  53
  54                 }while(at(pos)==0);
  55
  56                 return pos;
  57         }
  58         int findData(const BYTE* dataToFind, size_t dataSize, int start=0)
  59         {
  60                 //Pre checks
  61                 if(empty())
  62                         return -1;
  63                 if(dataSize==0)
  64                         return 0;
  65                 if(dataSize>size()-start)
  66                         return -1;//Data to find is greater then data to search in. No match
  67
  68                 //Initialize
  69                 const BYTE* pos=&*(begin()+start);
  70                 const BYTE* dataEnd=&*(begin()+(size()-dataSize) );++dataEnd;//Set end one step after last place to search
  71                 if(pos>=dataEnd)
  72                         return -1;//Started over end. Return not found
  73                 if(dataSize==0)
  74                         return start;//No search data. Return current position
  75                 BYTE firstByte=dataToFind[0];
  76                 while(pos<dataEnd)
  77                 {
  78                         //memchr for first character
  79                         const BYTE* found=(const BYTE*)memchr(pos,firstByte,dataEnd-pos);
  80                         if(found==NULL)
  81                                 return -1;//Not found
  82                         //check rest of characters
  83                         if(memcmp(found,dataToFind,dataSize)==0)
  84                                 return found-&*begin();//Match. Return position.
  85                         //No match. Set position on next byte and continue search
  86                         pos=found+1;
  87                 }
  88                 return -1;
  89         }
  90         int append( std::vector<BYTE> &v,int start=0,int end=-1)
  91         {
  92                 if(end<0)
  93                         end=v.size();
  94                 for(int i=start;i<end;i++)
  95                         this->push_back(v[i]);
  96                 return 0;
  97         }
  98         int append(const BYTE* data, size_t dataSize)
  99         {
 100                 size_t oldsize=size();
 101                 resize(oldsize+dataSize);
 102                 memcpy(&*(begin()+oldsize),data,dataSize);
 103                 return 0;
 104         }
 105 };
 106 typedef std::vector<CString> STRING_VECTOR;
 107 typedef std::map<CGitHash, STRING_VECTOR> MAP_HASH_NAME;
 108 typedef CGitByteArray BYTE_VECTOR;
 109