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