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-2017 - 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 "lanes.h"
  22 #include "GitHash.h"
  23 #include "Git.h"
  24 #include "GitLogCache.h"
  25 #include <unordered_map>
  26 #include <unordered_set>
  27 class CLogDlg;
  28
  29 /**
  30  * \ingroup TortoiseProc
  31  * Instances of CStoreSelection save the selection of the CLogDlg. When the instance
  32  * is deleted the destructor restores the selection.
  33  */
  34 typedef std::unordered_map<CGitHash, int> MAP_HASH_REV;
  35
  36 /**
  37  * \ingroup TortoiseProc
  38  * Helper class for the log dialog, handles all the log entries, including
  39  * sorting.
  40  */
  41 class CLogDataVector :  public std::vector<CGitHash>
  42 {
  43 public:
  44         CLogCache *m_pLogCache;
  45         /// De-allocates log items.
  46         CLogDataVector(CLogCache *pLogCache)
  47         {
  48                 m_pLogCache=pLogCache;
  49                 m_FirstFreeLane=0;
  50                 // Default to value set in Registry
  51                 m_logOrderBy = CRegDWORD(L"Software\\TortoiseGit\\LogOrderBy", CGit::LOG_ORDER_TOPOORDER);
  52         }
  53         CLogDataVector()
  54         {
  55                 m_pLogCache = nullptr;
  56                 m_FirstFreeLane=0;
  57                 // Default to value set in Registry
  58                 m_logOrderBy = CRegDWORD(L"Software\\TortoiseGit\\LogOrderBy", CGit::LOG_ORDER_TOPOORDER);
  59         }
  60         void SetLogCache(CLogCache *pLogCache)
  61         {
  62                 m_pLogCache = pLogCache;
  63         }
  64         GitRevLoglist& GetGitRevAt(size_t i)
  65         {
  66                 ASSERT(i<size());
  67                 return  m_pLogCache->m_HashMap[(*this)[i]];
  68         }
  69         void ClearAll();
  70         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);
  71         int  Fill(std::unordered_set<CGitHash>& hashes);
  72
  73         int FetchFullInfo(int i);
  74
  75         Lanes m_Lns;
  76         int      m_FirstFreeLane;
  77         // Log order: LOG_ORDER_CHRONOLOGIALREVERSED, LOG_ORDER_TOPOORDER, LOG_ORDER_DATEORDER
  78         int m_logOrderBy;
  79         MAP_HASH_REV m_HashMap;
  80         void updateLanes(GitRevLoglist& c, Lanes& lns, CGitHash& sha);
  81         void setLane(CGitHash& sha) ;
  82         void append(CGitHash& sha, bool storeInVector);
  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 };