src/Git/GitHash.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2017 - 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 #define GIT_REV_ZERO L"0000000000000000000000000000000000000000"
  24
  25 class CGitHash
  26 {
  27 public:
  28         unsigned char m_hash[GIT_HASH_SIZE];
  29
  30         CGitHash()
  31         {
  32                 memset(m_hash,0, GIT_HASH_SIZE);
  33         }
  34         CGitHash(const unsigned char* p)
  35         {
  36                 memcpy(m_hash,p,GIT_HASH_SIZE);
  37         }
  38         CGitHash & operator = (const CString &str)
  39         {
  40                 CGitHash hash(str);
  41                 *this = hash;
  42                 return *this;
  43         }
  44         CGitHash & operator = (const unsigned char *p)
  45         {
  46                 memcpy(m_hash, p, GIT_HASH_SIZE);
  47                 return *this;
  48         }
  49         CGitHash(const CString &str)
  50         {
  51                 if (!IsValidSHA1(str))
  52                 {
  53 #ifdef ASSERT
  54                         //ASSERT(FALSE); // TODO problematic
  55 #endif
  56                         memset(m_hash, 0, GIT_HASH_SIZE);
  57                         return;
  58                 }
  59
  60                 for (int i = 0; i < GIT_HASH_SIZE; ++i)
  61                 {
  62                         unsigned char a;
  63                         a=0;
  64                         for (int j = 2 * i; j <= 2 * i + 1; ++j)
  65                         {
  66                                 a =a<<4;
  67
  68                                 TCHAR ch = str[j];
  69                                 if (ch >= L'0' && ch <= L'9')
  70                                         a |= (ch - L'0') & 0xF;
  71                                 else if (ch >=L'A' && ch <= L'F')
  72                                         a |= ((ch - L'A') & 0xF) + 10 ;
  73                                 else if (ch >=L'a' && ch <= L'f')
  74                                         a |= ((ch - L'a') & 0xF) + 10;
  75
  76                         }
  77                         m_hash[i]=a;
  78                 }
  79         }
  80
  81         void ConvertFromStrA(const char *str)
  82         {
  83                 for (int i = 0; i < GIT_HASH_SIZE; ++i)
  84                 {
  85                         unsigned char a;
  86                         a=0;
  87                         for (int j = 2 * i; j <= 2 * i + 1; ++j)
  88                         {
  89                                 a =a<<4;
  90
  91                                 char ch = str[j];
  92                                 if (ch >= '0' && ch <= '9')
  93                                         a |= (ch - '0') & 0xF;
  94                                 else if (ch >= 'A' && ch <= 'F')
  95                                         a |= ((ch - 'A') & 0xF) + 10 ;
  96                                 else if (ch >= 'a' && ch <= 'f')
  97                                         a |= ((ch - 'a') & 0xF) + 10;
  98
  99                         }
 100                         m_hash[i]=a;
 101                 }
 102         }
 103         void Empty()
 104         {
 105                 memset(m_hash,0, GIT_HASH_SIZE);
 106         }
 107         bool IsEmpty() const
 108         {
 109                 for (int i = 0; i < GIT_HASH_SIZE; ++i)
 110                 {
 111                         if(m_hash[i] != 0)
 112                                 return false;
 113                 }
 114                 return true;
 115         }
 116
 117         CString ToString() const
 118         {
 119                 CString str;
 120                 for (int i = 0; i < GIT_HASH_SIZE; ++i)
 121                         str.AppendFormat(L"%02x", m_hash[i]);
 122                 return str;
 123         }
 124         operator CString () const
 125         {
 126                 return ToString();
 127         }
 128
 129         bool operator == (const CGitHash &hash) const
 130         {
 131                 return memcmp(m_hash,hash.m_hash,GIT_HASH_SIZE) == 0;
 132         }
 133
 134         static friend bool operator<(const CGitHash& left, const CGitHash& right)
 135         {
 136                 return memcmp(left.m_hash,right.m_hash,GIT_HASH_SIZE) < 0;
 137         }
 138
 139         static friend bool operator>(const CGitHash& left, const CGitHash& right)
 140         {
 141                 return memcmp(left.m_hash, right.m_hash, GIT_HASH_SIZE) > 0;
 142         }
 143
 144         static friend bool operator != (const CGitHash& left, const CGitHash& right)
 145         {
 146                 return memcmp(left.m_hash, right.m_hash, GIT_HASH_SIZE) != 0;
 147         }
 148
 149         bool MatchesPrefix(const CGitHash& hash, const CString& hashString, size_t prefixLen) const
 150         {
 151                 if (memcmp(m_hash, hash.m_hash, prefixLen >> 1))
 152                         return false;
 153                 return prefixLen == 2 * GIT_HASH_SIZE || wcsncmp(ToString(), hashString, prefixLen) == 0;
 154         }
 155
 156         static bool IsValidSHA1(const CString &possibleSHA1)
 157         {
 158                 if (possibleSHA1.GetLength() != 2 * GIT_HASH_SIZE)
 159                         return false;
 160                 for (int i = 0; i < possibleSHA1.GetLength(); ++i)
 161                 {
 162                         if (!((possibleSHA1[i] >= '0' && possibleSHA1[i] <= '9') || (possibleSHA1[i] >= 'a' && possibleSHA1[i] <= 'f') || (possibleSHA1[i] >= 'A' && possibleSHA1[i] <= 'F')))
 163                                 return false;
 164                 }
 165                 return true;
 166         }
 167 };
 168
 169 namespace std
 170 {
 171         template <>
 172         struct hash<CGitHash>
 173         {
 174                 std::size_t operator()(const CGitHash& k) const
 175                 {
 176                         return(size_t)*k.m_hash;
 177                 }
 178         };
 179 }