src/TortoiseProc/LogDlgHelper.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2007 - TortoiseSVN
   4 // Copyright (C) 2008-2015 - TortoiseGit
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 #pragma once
  21 #include "Git.h"
  22 #include "GitRevLoglist.h"
  23 #include "GitStatus.h"
  24 #include "ILogReceiver.h"
  25 #include "lanes.h"
  26 #include <set>
  27 #include "GitHash.h"
  28 #include "GitLogCache.h"
  29 class CLogDlg;
  30
  31 /**
  32  * \ingroup TortoiseProc
  33  * Instances of CStoreSelection save the selection of the CLogDlg. When the instance
  34  * is deleted the destructor restores the selection.
  35  */
  36 typedef std::map<CGitHash, int> MAP_HASH_REV;
  37
  38 /**
  39  * \ingroup TortoiseProc
  40  * Helper class for the log dialog, handles all the log entries, including
  41  * sorting.
  42  */
  43 class CLogDataVector :  public std::vector<CGitHash>
  44 {
  45 public:
  46         CLogCache *m_pLogCache;
  47         /// De-allocates log items.
  48         CLogDataVector(CLogCache *pLogCache)
  49         {
  50                 m_pLogCache=pLogCache;
  51                 m_FirstFreeLane=0;
  52         }
  53         CLogDataVector()
  54         {
  55                 m_pLogCache=NULL;
  56                 m_FirstFreeLane=0;
  57         }
  58         void SetLogCache(CLogCache *pLogCache)
  59         {
  60                 m_pLogCache = pLogCache;
  61         }
  62         GitRevLoglist& GetGitRevAt(size_t i)
  63         {
  64                 ASSERT(i<size());
  65                 return  m_pLogCache->m_HashMap[(*this)[i]];
  66         }
  67         void ClearAll();
  68         int  ParserFromLog(CTGitPath* path = nullptr, DWORD count = 0, DWORD infomask = CGit::LOG_INFO_STAT | CGit::LOG_INFO_FILESTATE | CGit::LOG_INFO_SHOW_MERGEDFILE, CString* range = nullptr);
  69         int  Fill(std::set<CGitHash>& hashes);
  70
  71         int FetchFullInfo(int i);
  72 //      void AddFullInfo(
  73
  74         Lanes m_Lns;
  75         int      m_FirstFreeLane;
  76         MAP_HASH_REV m_HashMap;
  77         void updateLanes(GitRevLoglist& c, Lanes& lns, CGitHash& sha);
  78         void setLane(CGitHash& sha) ;
  79         void append(CGitHash& sha, bool storeInVector);
  80
  81         BYTE_VECTOR              m_RawlogData;
  82         std::vector<int> m_RawLogStart;
  83
  84 #if 0
  85         /// Ascending date sorting.
  86         struct AscDateSort
  87         {
  88                 bool operator()(GitRev& pStart, GitRev& pEnd)
  89                 {
  90                         return pStart->tmDate < pEnd->tmDate;
  91                 }
  92         };
  93         /// Descending date sorting.
  94         struct DescDateSort
  95         {
  96                 bool operator()(GitRev& pStart, GitRev& pEnd)
  97                 {
  98                         return pStart->tmDate > pEnd->tmDate;
  99                 }
 100         };
 101         /// Ascending revision sorting.
 102         struct AscRevSort
 103         {
 104                 bool operator()(GitRev& pStart, GitRev& pEnd)
 105                 {
 106                         return pStart->Rev < pEnd->Rev;
 107                 }
 108         };
 109         /// Descending revision sorting.
 110         struct DescRevSort
 111         {
 112                 bool operator()(GitRev& pStart, GitRev& pEnd)
 113                 {
 114                         return pStart->Rev > pEnd->Rev;
 115                 }
 116         };
 117         /// Ascending author sorting.
 118         struct AscAuthorSort
 119         {
 120                 bool operator()(GitRev& pStart, GitRev& pEnd)
 121                 {
 122                         int ret = pStart->sAuthor.CompareNoCase(pEnd->sAuthor);
 123                         if (ret == 0)
 124                                 return pStart->Rev < pEnd->Rev;
 125                         return ret<0;
 126                 }
 127         };
 128         /// Descending author sorting.
 129         struct DescAuthorSort
 130         {
 131                 bool operator()(GitRev& pStart, GitRev& pEnd)
 132                 {
 133                         int ret = pStart->sAuthor.CompareNoCase(pEnd->sAuthor);
 134                         if (ret == 0)
 135                                 return pStart->Rev > pEnd->Rev;
 136                         return ret>0;
 137                 }
 138         };
 139         /// Ascending bugID sorting.
 140         struct AscBugIDSort
 141         {
 142                 bool operator()(GitRev& pStart, GitRev& pEnd)
 143                 {
 144                         int ret = pStart->sBugIDs.CompareNoCase(pEnd->sBugIDs);
 145                         if (ret == 0)
 146                                 return pStart->Rev < pEnd->Rev;
 147                         return ret<0;
 148                 }
 149         };
 150         /// Descending bugID sorting.
 151         struct DescBugIDSort
 152         {
 153                 bool operator()(GitRev& pStart, GitRev& pEnd)
 154                 {
 155                         int ret = pStart->sBugIDs.CompareNoCase(pEnd->sBugIDs);
 156                         if (ret == 0)
 157                                 return pStart->Rev > pEnd->Rev;
 158                         return ret>0;
 159                 }
 160         };
 161         /// Ascending message sorting.
 162         struct AscMessageSort
 163         {
 164                 bool operator()(GitRev& pStart, GitRev& pEnd)
 165                 {
 166                         return pStart->sShortMessage.CompareNoCase(pEnd->sShortMessage)<0;
 167                 }
 168         };
 169         /// Descending message sorting.
 170         struct DescMessageSort
 171         {
 172                 bool operator()(GitRev& pStart, GitRev& pEnd)
 173                 {
 174                         return pStart->sShortMessage.CompareNoCase(pEnd->sShortMessage)>0;
 175                 }
 176         };
 177         /// Ascending action sorting
 178         struct AscActionSort
 179         {
 180                 bool operator() (GitRev& pStart, GitRev& pEnd)
 181                 {
 182                         if (pStart->actions == pEnd->actions)
 183                                 return pStart->Rev < pEnd->Rev;
 184                         return pStart->actions < pEnd->actions;
 185                 }
 186         };
 187         /// Descending action sorting
 188         struct DescActionSort
 189         {
 190                 bool operator() (GitRev& pStart, GitRev& pEnd)
 191                 {
 192                         if (pStart->actions == pEnd->actions)
 193                                 return pStart->Rev > pEnd->Rev;
 194                         return pStart->actions > pEnd->actions;
 195                 }
 196         };
 197 #endif
 198 };