src/Git/GitHash.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2018 - TortoiseGit
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19
  20 #pragma once
  21 #define GIT_HASH_SIZE 20
  22
  23 /* also see gitdll.c */
  24 static_assert(GIT_HASH_SIZE == GIT_OID_RAWSZ, "hash size needs to be the same as in libgit2");
  25 static_assert(sizeof(git_oid::id) == GIT_HASH_SIZE, "hash size needs to be the same as in libgit2");
  26
  27 #define GIT_REV_ZERO_C "0000000000000000000000000000000000000000"
  28 #define GIT_REV_ZERO _T(GIT_REV_ZERO_C)
  29
  30 class CGitHash;
  31 template<>
  32 struct std::hash<CGitHash>;
  33
  34 class CGitHash
  35 {
  36 private:
  37         unsigned char m_hash[GIT_HASH_SIZE];
  38 public:
  39         CGitHash()
  40         {
  41                 memset(m_hash,0, GIT_HASH_SIZE);
  42         }
  43         CGitHash(const unsigned char* p)
  44         {
  45                 memcpy(m_hash,p,GIT_HASH_SIZE);
  46         }
  47         CGitHash(const git_oid* oid)
  48         {
  49                 git_oid_cpy((git_oid*)m_hash, oid);
  50         }
  51         CGitHash(const git_oid oid)
  52         {
  53                 git_oid_cpy((git_oid*)m_hash, &oid);
  54         }
  55         CGitHash& operator = (const CString& str)
  56         {
  57                 CGitHash hash(str);
  58                 *this = hash;
  59                 return *this;
  60         }
  61         CGitHash& operator = (const unsigned char *p)
  62         {
  63                 memcpy(m_hash, p, GIT_HASH_SIZE);
  64                 return *this;
  65         }
  66         CGitHash& operator = (const git_oid* oid)
  67         {
  68                 git_oid_cpy((git_oid*)m_hash, oid);
  69                 return *this;
  70         }
  71         CGitHash& operator = (const git_oid oid)
  72         {
  73                 git_oid_cpy((git_oid*)m_hash, &oid);
  74                 return *this;
  75         }
  76         CGitHash(const CString &str)
  77         {
  78                 if (!IsValidSHA1(str))
  79                 {
  80 #ifdef ASSERT
  81                         //ASSERT(FALSE); // TODO problematic
  82 #endif
  83                         memset(m_hash, 0, GIT_HASH_SIZE);
  84                         return;
  85                 }
  86
  87                 for (int i = 0; i < GIT_HASH_SIZE; ++i)
  88                 {
  89                         unsigned char a;
  90                         a=0;
  91                         for (int j = 2 * i; j <= 2 * i + 1; ++j)
  92                         {
  93                                 a =a<<4;
  94
  95                                 TCHAR ch = str[j];
  96                                 if (ch >= L'0' && ch <= L'9')
  97                                         a |= (ch - L'0') & 0xF;
  98                                 else if (ch >=L'A' && ch <= L'F')
  99                                         a |= ((ch - L'A') & 0xF) + 10 ;
 100                                 else if (ch >=L'a' && ch <= L'f')
 101                                         a |= ((ch - L'a') & 0xF) + 10;
 102
 103                         }
 104                         m_hash[i]=a;
 105                 }
 106         }
 107
 108         void ConvertFromStrA(const char *str)
 109         {
 110                 for (int i = 0; i < GIT_HASH_SIZE; ++i)
 111                 {
 112                         unsigned char a;
 113                         a=0;
 114                         for (int j = 2 * i; j <= 2 * i + 1; ++j)
 115                         {
 116                                 a =a<<4;
 117
 118                                 char ch = str[j];
 119                                 if (ch >= '0' && ch <= '9')
 120                                         a |= (ch - '0') & 0xF;
 121                                 else if (ch >= 'A' && ch <= 'F')
 122                                         a |= ((ch - 'A') & 0xF) + 10 ;
 123                                 else if (ch >= 'a' && ch <= 'f')
 124                                         a |= ((ch - 'a') & 0xF) + 10;
 125
 126                         }
 127                         m_hash[i]=a;
 128                 }
 129         }
 130         void Empty()
 131         {
 132                 memset(m_hash,0, GIT_HASH_SIZE);
 133         }
 134         bool IsEmpty() const
 135         {
 136                 for (int i = 0; i < GIT_HASH_SIZE; ++i)
 137                 {
 138                         if(m_hash[i] != 0)
 139                                 return false;
 140                 }
 141                 return true;
 142         }
 143
 144         CString ToString() const
 145         {
 146                 CString str;
 147                 str.Preallocate(GIT_HASH_SIZE * 2);
 148                 for (int i = 0; i < GIT_HASH_SIZE; ++i)
 149                         str.AppendFormat(L"%02x", m_hash[i]);
 150                 return str;
 151         }
 152
 153         operator const git_oid*() const
 154         {
 155                 return (const git_oid*)m_hash;
 156         }
 157
 158         explicit operator const unsigned char*() const
 159         {
 160                 return m_hash;
 161         }
 162
 163         bool operator == (const CGitHash &hash) const
 164         {
 165                 return memcmp(m_hash,hash.m_hash,GIT_HASH_SIZE) == 0;
 166         }
 167
 168         static friend bool operator<(const CGitHash& left, const CGitHash& right)
 169         {
 170                 return memcmp(left.m_hash,right.m_hash,GIT_HASH_SIZE) < 0;
 171         }
 172
 173         static friend bool operator>(const CGitHash& left, const CGitHash& right)
 174         {
 175                 return memcmp(left.m_hash, right.m_hash, GIT_HASH_SIZE) > 0;
 176         }
 177
 178         static friend bool operator != (const CGitHash& left, const CGitHash& right)
 179         {
 180                 return memcmp(left.m_hash, right.m_hash, GIT_HASH_SIZE) != 0;
 181         }
 182
 183         bool MatchesPrefix(const CGitHash& hash, const CString& hashString, size_t prefixLen) const
 184         {
 185                 if (memcmp(m_hash, hash.m_hash, prefixLen >> 1))
 186                         return false;
 187                 return prefixLen == 2 * GIT_HASH_SIZE || wcsncmp(ToString(), hashString, prefixLen) == 0;
 188         }
 189
 190         static bool IsValidSHA1(const CString &possibleSHA1)
 191         {
 192                 if (possibleSHA1.GetLength() != 2 * GIT_HASH_SIZE)
 193                         return false;
 194                 for (int i = 0; i < possibleSHA1.GetLength(); ++i)
 195                 {
 196                         if (!((possibleSHA1[i] >= '0' && possibleSHA1[i] <= '9') || (possibleSHA1[i] >= 'a' && possibleSHA1[i] <= 'f') || (possibleSHA1[i] >= 'A' && possibleSHA1[i] <= 'F')))
 197                                 return false;
 198                 }
 199                 return true;
 200         }
 201
 202         friend struct std::hash<CGitHash>;
 203 };
 204
 205 namespace std
 206 {
 207         template <>
 208         struct hash<CGitHash>
 209         {
 210                 std::size_t operator()(const CGitHash& k) const
 211                 {
 212                         return *(size_t*)k.m_hash;
 213                 }
 214         };
 215 }