src/TortoiseProc/GitLogCache.cpp

   1 #include "stdafx.h"
   2 #include "GitLogCache.h"
   3
   4 CLogCache::CLogCache()
   5 {
   6
   7 }
   8
   9 CLogCache::~CLogCache()
  10 {
  11         //this->m_IndexFile.Close();
  12         //this->m_DataFile.Close();
  13 }
  14 int CLogCache::AddCacheEntry(GitRev &Rev)
  15 {
  16         this->m_HashMap[Rev.m_CommitHash] = Rev;
  17         return 0;
  18 }
  19
  20 int CLogCache::GetCacheData(GitRev &Rev)
  21 {
  22         if(this->m_HashMapIndex.find(Rev.m_CommitHash)==m_HashMapIndex.end())
  23         {
  24                 if(this->m_HashMap.IsExist(Rev.m_CommitHash))
  25                 {
  26                         Rev.CopyFrom(m_HashMap[Rev.m_CommitHash]);
  27                         return 0;
  28                 }
  29                 return -1;
  30         }
  31         else
  32         {
  33                 return LoadOneItem(Rev,m_HashMapIndex[Rev.m_CommitHash]);
  34         }
  35         return 0;
  36 }
  37 int CLogCache::FetchCacheIndex(CString GitDir)
  38 {
  39
  40         if(this->m_IndexFile.m_hFile == CFile::hFileNull)
  41         {
  42                 BOOL b=m_IndexFile.Open(GitDir+_T("\\.git\\")+INDEX_FILE_NAME,
  43                         CFile::modeRead|CFile::shareDenyNone|
  44                         CFile::modeNoTruncate|CFile::modeCreate);
  45                 if(!b)
  46                         return -1;
  47         }
  48         //Cache has been fetched.
  49         //if(m_GitDir == GitDir)
  50         //      return 0;
  51
  52         m_GitDir=GitDir;
  53         m_IndexFile.SeekToBegin();
  54
  55         SLogCacheIndexHeader header;
  56         UINT count=m_IndexFile.Read(&header,sizeof(SLogCacheIndexHeader));
  57         if(count != sizeof(SLogCacheIndexHeader))
  58                 return -2;
  59
  60         if( header.m_Magic != LOG_INDEX_MAGIC )
  61                 return -3;
  62
  63         if( header.m_Version != LOG_INDEX_VERSION )
  64                 return -4;
  65
  66
  67         SLogCacheItem Item;
  68
  69         //for(int i=0;i<header.m_ItemCount;i++)
  70         this->m_HashMapIndex.clear();
  71
  72         while(1)
  73         {
  74                 count=m_IndexFile.Read(&Item,sizeof(SLogCacheItem));
  75                 if( count != sizeof(SLogCacheItem) )
  76                         break;
  77
  78                 this->m_HashMapIndex[Item.m_Hash]=Item.m_Offset;
  79         }
  80
  81         return 0;
  82 }
  83
  84 int CLogCache::SaveOneItem(GitRev &Rev,ULONGLONG offset)
  85 {
  86
  87         SLogCacheRevItemHeader header;
  88         m_DataFile.Seek(offset,CFile::begin);
  89
  90         if(this->m_DataFile.m_hFile == CFile::hFileNull)
  91         {
  92                 BOOL b=m_DataFile.Open(m_GitDir+_T("\\.git\\")+INDEX_FILE_NAME,
  93                         CFile::modeRead|CFile::shareDenyNone|
  94                         CFile::modeNoTruncate|CFile::modeCreate);
  95                 if(!b)
  96                         return -1;
  97         }
  98
  99         header.m_Magic=LOG_DATA_ITEM_MAGIC;
 100         header.m_Version=LOG_INDEX_VERSION;
 101         header.m_FileCount=Rev.m_Files.GetCount();
 102
 103         m_DataFile.Write(&header,sizeof(SLogCacheRevItemHeader));
 104
 105         CArchive ar(&m_DataFile, CArchive::store);
 106
 107         ar<<Rev.m_AuthorName;
 108         ar<<Rev.m_AuthorEmail;
 109         ar<<Rev.m_AuthorDate;
 110         ar<<Rev.m_CommitterName;
 111         ar<<Rev.m_CommitterEmail;
 112         ar<<Rev.m_CommitterDate;
 113         ar<<Rev.m_Subject;
 114         ar<<Rev.m_Body;
 115         ar<<Rev.m_CommitHash;
 116         ar<<Rev.m_Action;
 117
 118         for(int i=0;i<Rev.m_Files.GetCount();i++)
 119         {
 120                 SLogCacheRevFileHeader header;
 121                 header.m_Magic=LOG_DATA_FILE_MAGIC;
 122                 header.m_Version=LOG_INDEX_VERSION;
 123
 124                 ar<<header.m_Magic;
 125                 ar<<header.m_Version;
 126                 ar<<Rev.m_Files[i].GetGitPathString();
 127                 ar<<Rev.m_Files[i].GetGitOldPathString();
 128                 ar<<Rev.m_Files[i].m_Action;
 129                 ar<<Rev.m_Files[i].m_Stage;
 130                 ar<<Rev.m_Files[i].m_StatAdd;
 131                 ar<<Rev.m_Files[i].m_StatDel;
 132
 133         }
 134         return 0;
 135 }
 136
 137 int CLogCache::LoadOneItem(GitRev &Rev,ULONGLONG offset)
 138 {
 139         SLogCacheRevItemHeader header;
 140
 141         if(this->m_DataFile.m_hFile == CFile::hFileNull)
 142         {
 143                 BOOL b=m_DataFile.Open(m_GitDir+_T("\\.git\\")+DATA_FILE_NAME,
 144                         CFile::modeRead|CFile::shareDenyNone|
 145                         CFile::modeNoTruncate|CFile::modeCreate);
 146                 if(!b)
 147                         return -1;
 148         }
 149         m_DataFile.Seek(offset,CFile::begin);
 150
 151         UINT count=m_DataFile.Read(&header,sizeof(SLogCacheRevItemHeader));
 152         if( count != sizeof(SLogCacheRevItemHeader))
 153                 return -1;
 154         if( !CheckHeader(header))
 155                 return -2;
 156
 157
 158         CArchive ar(&m_DataFile, CArchive::load);
 159
 160         ar>>Rev.m_AuthorName;
 161         ar>>Rev.m_AuthorEmail;
 162         ar>>Rev.m_AuthorDate;
 163         ar>>Rev.m_CommitterName;
 164         ar>>Rev.m_CommitterEmail;
 165         ar>>Rev.m_CommitterDate;
 166         ar>>Rev.m_Subject;
 167         ar>>Rev.m_Body;
 168         ar>>Rev.m_CommitHash;
 169         ar>>Rev.m_Action;
 170
 171         Rev.m_Files.Clear();
 172
 173         for(int i=0;i<header.m_FileCount;i++)
 174         {
 175                 CTGitPath path;
 176                 CString file,oldfile;
 177                 path.Reset();
 178                 SLogCacheRevFileHeader header;
 179
 180                 ar>>header.m_Magic;
 181                 ar>>header.m_Version;
 182
 183                 if( this->CheckHeader(header) )
 184                         return -1;
 185                 ar>>file;
 186                 ar>>oldfile;
 187                 path.SetFromGit(file,&oldfile);
 188
 189                 ar>>path.m_Action;
 190                 ar>>path.m_Stage;
 191                 ar>>path.m_StatAdd;
 192                 ar>>path.m_StatDel;
 193
 194
 195                 Rev.m_Files.AddPath(path);
 196         }
 197         return 0;
 198 }
 199 int CLogCache::RebuildCacheFile()
 200 {
 201         m_IndexFile.SetLength(0);
 202         m_DataFile.SetLength(0);
 203         {
 204                 SLogCacheIndexHeader header;
 205                 header.m_Magic=LOG_INDEX_MAGIC;
 206                 header.m_Version=LOG_INDEX_VERSION;
 207                 m_IndexFile.SeekToBegin();
 208                 m_IndexFile.Write(&header,sizeof(SLogCacheIndexHeader));
 209         }
 210
 211         {
 212                 SLogCacheRevFileHeader header;
 213                 header.m_Magic=LOG_DATA_MAGIC;
 214                 header.m_Version=LOG_INDEX_VERSION;
 215
 216                 m_DataFile.SeekToBegin();
 217                 m_DataFile.Write(&header,sizeof(SLogCacheRevFileHeader));
 218         }
 219         return 0;
 220 }
 221 int CLogCache::SaveCache()
 222 {
 223         if( this->m_HashMap.size() == 0 )
 224                 return 0;
 225
 226         bool bIsRebuild=false;
 227         if(this->m_DataFile.m_hFile != CFile::hFileNull)
 228                 m_DataFile.Close();
 229         if(this->m_IndexFile.m_hFile!=CFile::hFileNull)
 230                 m_IndexFile.Close();
 231
 232         if(this->m_IndexFile.m_hFile == CFile::hFileNull)
 233         {
 234                 BOOL b=m_IndexFile.Open(m_GitDir+_T("\\.git\\")+INDEX_FILE_NAME,
 235                         CFile::modeReadWrite|CFile::shareDenyWrite|
 236                         CFile::modeNoTruncate|CFile::modeCreate);
 237                 if(!b)
 238                         return -1;
 239         }
 240
 241         if(this->m_DataFile.m_hFile == CFile::hFileNull)
 242         {
 243                 BOOL b=m_DataFile.Open(m_GitDir+_T("\\.git\\")+DATA_FILE_NAME,
 244                         CFile::modeReadWrite|CFile::shareDenyWrite|
 245                         CFile::modeNoTruncate|CFile::modeCreate);
 246
 247
 248                 if(!b)
 249                 {
 250                         m_IndexFile.Close();
 251                         return -1;
 252                 }
 253         }
 254
 255         {
 256                 SLogCacheIndexHeader header;
 257                 memset(&header,0,sizeof(SLogCacheIndexHeader));
 258                 UINT count=m_IndexFile.Read(&header,sizeof(SLogCacheIndexHeader));
 259                 if(count != sizeof(SLogCacheIndexHeader) || !this->CheckHeader(header))
 260                 {// new file
 261                         RebuildCacheFile();
 262                         bIsRebuild=true;
 263                 }
 264         }
 265
 266         {
 267
 268                 SLogCacheRevFileHeader header;
 269
 270                 UINT count=m_DataFile.Read(&header,sizeof(SLogCacheRevFileHeader));
 271                 if( count != sizeof(SLogCacheRevFileHeader) || !CheckHeader(header))
 272                 {
 273                         RebuildCacheFile();
 274                         bIsRebuild=true;
 275                 }
 276
 277         }
 278
 279         m_DataFile.SeekToEnd();
 280         m_IndexFile.SeekToEnd();
 281         CGitHashMap::iterator i;
 282         for(i=m_HashMap.begin();i!=m_HashMap.end();i++)
 283         {
 284                 if(this->m_HashMapIndex.find((*i).second.m_CommitHash) == m_HashMapIndex.end() || bIsRebuild)
 285                 {
 286                         if((*i).second.m_IsFull)
 287                         {
 288                                 ULONGLONG offset = m_DataFile.GetPosition();
 289                                 this->SaveOneItem((*i).second,offset);
 290
 291                                 SLogCacheItem item;
 292                                 item.m_Hash = (*i).second.m_CommitHash;
 293                                 item.m_Offset=offset;
 294
 295                                 m_IndexFile.Write(&item,sizeof(SLogCacheItem));
 296                         }
 297                 }
 298         }
 299         m_IndexFile.Close();
 300         m_DataFile.Close();
 301         return 0;
 302 }