src/Utils/SmartLibgit2Ref.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2014-2017 - TortoiseGit
   4 // based on SmartHandle of TortoiseSVN
   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 "UnicodeUtils.h"
  22
  23 /**
  24 * \ingroup Utils
  25 * Helper classes for libgit2 references.
  26 */
  27 template <typename HandleType, void FreeFunction(HandleType*)>
  28 class CSmartBuffer
  29 {
  30 public:
  31         CSmartBuffer()
  32                 : m_Ref({0})
  33         {
  34         }
  35
  36         operator HandleType*()
  37         {
  38                 return &m_Ref;
  39         }
  40
  41         HandleType* operator->()
  42         {
  43                 return &m_Ref;
  44         }
  45
  46         ~CSmartBuffer()
  47         {
  48                 FreeFunction(&m_Ref);
  49         }
  50
  51 private:
  52         CSmartBuffer(const CSmartBuffer&) = delete;
  53         CSmartBuffer& operator=(const CSmartBuffer&) = delete;
  54
  55         HandleType m_Ref;
  56 };
  57
  58 typedef CSmartBuffer<git_buf,                   git_buf_free>                                           CAutoBuf;
  59 typedef CSmartBuffer<git_strarray,              git_strarray_free>                                      CAutoStrArray;
  60
  61 template <typename ReferenceType, void FreeFunction(ReferenceType*)>
  62 class CSmartLibgit2Ref
  63 {
  64 public:
  65         CSmartLibgit2Ref()
  66                 : m_Ref(nullptr)
  67         {
  68         }
  69
  70         ~CSmartLibgit2Ref()
  71         {
  72                 Free();
  73         }
  74
  75         void Swap(CSmartLibgit2Ref& tmp)
  76         {
  77                 ReferenceType* p;
  78
  79                 p = m_Ref;
  80                 m_Ref = tmp.m_Ref;
  81                 tmp.m_Ref = p;
  82         }
  83
  84         void Free()
  85         {
  86                 FreeFunction(m_Ref);
  87                 m_Ref = nullptr;
  88         }
  89
  90         ReferenceType* Detach()
  91         {
  92                 ReferenceType* p = m_Ref;
  93                 m_Ref = nullptr;
  94
  95                 return p;
  96         }
  97
  98         operator ReferenceType*() const
  99         {
 100                 return m_Ref;
 101         }
 102
 103         /**
 104          * Free the wrapped object and return a pointer to the wrapped object ReferenceType*
 105          */
 106         ReferenceType** GetPointer()
 107         {
 108                 Free();
 109                 return &m_Ref;
 110         }
 111
 112         operator bool() const
 113         {
 114                 return IsValid();
 115         }
 116
 117         bool IsValid() const
 118         {
 119                 return m_Ref != nullptr;
 120         }
 121
 122 private:
 123         CSmartLibgit2Ref(const CSmartLibgit2Ref&) = delete;
 124         CSmartLibgit2Ref& operator=(const CSmartLibgit2Ref&) = delete;
 125
 126 protected:
 127         ReferenceType* m_Ref;
 128 };
 129
 130 typedef CSmartLibgit2Ref<git_object,                            git_object_free>                                CAutoObject;
 131 typedef CSmartLibgit2Ref<git_submodule,                         git_submodule_free>                             CAutoSubmodule;
 132 typedef CSmartLibgit2Ref<git_blob,                                      git_blob_free>                                  CAutoBlob;
 133 typedef CSmartLibgit2Ref<git_reference,                         git_reference_free>                             CAutoReference;
 134 typedef CSmartLibgit2Ref<git_tag,                                       git_tag_free>                                   CAutoTag;
 135 typedef CSmartLibgit2Ref<git_tree_entry,                        git_tree_entry_free>                    CAutoTreeEntry;
 136 typedef CSmartLibgit2Ref<git_diff,                                      git_diff_free>                                  CAutoDiff;
 137 typedef CSmartLibgit2Ref<git_patch,                                     git_patch_free>                                 CAutoPatch;
 138 typedef CSmartLibgit2Ref<git_diff_stats,                        git_diff_stats_free>                    CAutoDiffStats;
 139 typedef CSmartLibgit2Ref<git_index,                                     git_index_free>                                 CAutoIndex;
 140 typedef CSmartLibgit2Ref<git_remote,                            git_remote_free>                                CAutoRemote;
 141 typedef CSmartLibgit2Ref<git_reflog,                            git_reflog_free>                                CAutoReflog;
 142 typedef CSmartLibgit2Ref<git_revwalk,                           git_revwalk_free>                               CAutoRevwalk;
 143 typedef CSmartLibgit2Ref<git_branch_iterator,           git_branch_iterator_free>               CAutoBranchIterator;
 144 typedef CSmartLibgit2Ref<git_reference_iterator,        git_reference_iterator_free>    CAutoReferenceIterator;
 145 typedef CSmartLibgit2Ref<git_describe_result,           git_describe_result_free>               CAutoDescribeResult;
 146 typedef CSmartLibgit2Ref<git_status_list,                       git_status_list_free>                   CAutoStatusList;
 147 typedef CSmartLibgit2Ref<git_note,                                      git_note_free>                                  CAutoNote;
 148
 149 class CAutoRepository : public CSmartLibgit2Ref<git_repository, git_repository_free>
 150 {
 151 public:
 152         CAutoRepository() {};
 153
 154         explicit CAutoRepository(git_repository*&& h)
 155         {
 156                 m_Ref = h;
 157         }
 158
 159         CAutoRepository(CAutoRepository&& that)
 160         {
 161                 m_Ref = that.Detach();
 162         }
 163
 164 #if defined(_MFC_VER) || defined(CSTRING_AVAILABLE)
 165         CAutoRepository(const CString& gitDir)
 166         {
 167                 Open(gitDir);
 168         }
 169
 170         CAutoRepository(const CStringA& gitDirA)
 171         {
 172                 Open(gitDirA);
 173         }
 174
 175         int Open(const CString& gitDir)
 176         {
 177                 return Open(CUnicodeUtils::GetUTF8(gitDir));
 178         }
 179 #endif
 180
 181 private:
 182         CAutoRepository(const CAutoRepository&) = delete;
 183         CAutoRepository& operator=(const CAutoRepository&) = delete;
 184
 185 protected:
 186         int Open(const char* gitDirA)
 187         {
 188                 return git_repository_open(GetPointer(), gitDirA);
 189         }
 190 };
 191
 192 class CAutoCommit : public CSmartLibgit2Ref<git_commit, git_commit_free>
 193 {
 194 public:
 195         CAutoCommit() {}
 196
 197         explicit CAutoCommit(git_commit*&& h)
 198         {
 199                 m_Ref = h;
 200         }
 201
 202 private:
 203         CAutoCommit(const CAutoCommit&) = delete;
 204         CAutoCommit& operator=(const CAutoCommit&) = delete;
 205 };
 206
 207 class CAutoTree : public CSmartLibgit2Ref<git_tree, git_tree_free>
 208 {
 209 public:
 210         CAutoTree() {};
 211
 212         void ConvertFrom(CAutoObject&& h)
 213         {
 214                 if (m_Ref != (git_tree*)(git_object*)h)
 215                 {
 216                         Free();
 217                         m_Ref = (git_tree*)h.Detach();
 218                 }
 219         }
 220
 221 private:
 222         CAutoTree(const CAutoTree&) = delete;
 223         CAutoTree& operator=(const CAutoTree&) = delete;
 224 };
 225
 226 class CAutoConfig : public CSmartLibgit2Ref<git_config, git_config_free>
 227 {
 228 public:
 229         CAutoConfig() {}
 230
 231         CAutoConfig(CAutoRepository &repo)
 232         {
 233                 git_repository_config(&m_Ref, repo);
 234         }
 235
 236         CAutoConfig(bool init)
 237         {
 238                 if (init)
 239                         New();
 240         }
 241
 242         void New()
 243         {
 244                 Free();
 245                 git_config_new(&m_Ref);
 246         }
 247
 248 #if defined(_MFC_VER) || defined(CSTRING_AVAILABLE)
 249         int GetString(const CString &key, CString &value) const
 250         {
 251                 if (!IsValid())
 252                         return -1;
 253
 254                 CAutoBuf buf;
 255                 int ret = 0;
 256                 if ((ret = git_config_get_string_buf(buf, m_Ref, CUnicodeUtils::GetUTF8(key))))
 257                 {
 258                         value.Empty();
 259                         return ret;
 260                 }
 261
 262                 value = CUnicodeUtils::GetUnicode((CStringA)buf->ptr);
 263
 264                 return ret;
 265         }
 266
 267         int GetBOOL(const CString &key, BOOL &b) const
 268         {
 269                 if (!IsValid())
 270                         return -1;
 271
 272                 return git_config_get_bool(&b, m_Ref, CUnicodeUtils::GetUTF8(key));
 273         }
 274
 275         int GetBool(const CString &key, bool &b) const
 276         {
 277                 if (!IsValid())
 278                         return -1;
 279
 280                 int value = FALSE;
 281                 int ret = 0;
 282                 if ((ret = GetBOOL(key, value)) < 0)
 283                         return ret;
 284
 285                 b = (value == TRUE);
 286
 287                 return ret;
 288         }
 289 #endif
 290
 291 private:
 292         CAutoConfig(const CAutoConfig&) = delete;
 293         CAutoConfig& operator=(const CAutoConfig&) = delete;
 294 };