src/Git/GitHash.h

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