src/Utils/SmartLibgit2Ref.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2014-2018 - 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_dispose>                                        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 typedef CSmartLibgit2Ref<git_signature,                         git_signature_free>                             CAutoSignature;
 149
 150 class CAutoRepository : public CSmartLibgit2Ref<git_repository, git_repository_free>
 151 {
 152 public:
 153         CAutoRepository() {};
 154
 155         explicit CAutoRepository(git_repository*&& h)
 156         {
 157                 m_Ref = h;
 158         }
 159
 160         CAutoRepository(CAutoRepository&& that)
 161         {
 162                 m_Ref = that.Detach();
 163         }
 164
 165 #if defined(_MFC_VER) || defined(CSTRING_AVAILABLE)
 166         CAutoRepository(const CString& gitDir)
 167         {
 168                 Open(gitDir);
 169         }
 170
 171         CAutoRepository(const CStringA& gitDirA)
 172         {
 173                 Open(gitDirA);
 174         }
 175
 176         int Open(const CString& gitDir)
 177         {
 178                 return Open(CUnicodeUtils::GetUTF8(gitDir));
 179         }
 180 #endif
 181
 182 private:
 183         CAutoRepository(const CAutoRepository&) = delete;
 184         CAutoRepository& operator=(const CAutoRepository&) = delete;
 185
 186 protected:
 187         int Open(const char* gitDirA)
 188         {
 189                 return git_repository_open(GetPointer(), gitDirA);
 190         }
 191 };
 192
 193 class CAutoCommit : public CSmartLibgit2Ref<git_commit, git_commit_free>
 194 {
 195 public:
 196         CAutoCommit() {}
 197
 198         explicit CAutoCommit(git_commit*&& h)
 199         {
 200                 m_Ref = h;
 201         }
 202
 203 private:
 204         CAutoCommit(const CAutoCommit&) = delete;
 205         CAutoCommit& operator=(const CAutoCommit&) = delete;
 206 };
 207
 208 class CAutoTree : public CSmartLibgit2Ref<git_tree, git_tree_free>
 209 {
 210 public:
 211         CAutoTree() {};
 212
 213         void ConvertFrom(CAutoObject&& h)
 214         {
 215                 if (m_Ref != (git_tree*)(git_object*)h)
 216                 {
 217                         Free();
 218                         m_Ref = (git_tree*)h.Detach();
 219                 }
 220         }
 221
 222 private:
 223         CAutoTree(const CAutoTree&) = delete;
 224         CAutoTree& operator=(const CAutoTree&) = delete;
 225 };
 226
 227 class CAutoConfig : public CSmartLibgit2Ref<git_config, git_config_free>
 228 {
 229 public:
 230         CAutoConfig() {}
 231
 232         CAutoConfig(CAutoRepository &repo)
 233         {
 234                 git_repository_config(&m_Ref, repo);
 235         }
 236
 237         CAutoConfig(bool init)
 238         {
 239                 if (init)
 240                         New();
 241         }
 242
 243         void New()
 244         {
 245                 Free();
 246                 git_config_new(&m_Ref);
 247         }
 248
 249 #if defined(_MFC_VER) || defined(CSTRING_AVAILABLE)
 250         int GetString(const CString &key, CString &value) const
 251         {
 252                 if (!IsValid())
 253                         return -1;
 254
 255                 CAutoBuf buf;
 256                 int ret = 0;
 257                 if ((ret = git_config_get_string_buf(buf, m_Ref, CUnicodeUtils::GetUTF8(key))))
 258                 {
 259                         value.Empty();
 260                         return ret;
 261                 }
 262
 263                 value = CUnicodeUtils::GetUnicode((CStringA)buf->ptr);
 264
 265                 return ret;
 266         }
 267
 268         int GetBOOL(const CString &key, BOOL &b) const
 269         {
 270                 if (!IsValid())
 271                         return -1;
 272
 273                 return git_config_get_bool(&b, m_Ref, CUnicodeUtils::GetUTF8(key));
 274         }
 275
 276         int GetBool(const CString &key, bool &b) const
 277         {
 278                 if (!IsValid())
 279                         return -1;
 280
 281                 int value = FALSE;
 282                 int ret = 0;
 283                 if ((ret = GetBOOL(key, value)) < 0)
 284                         return ret;
 285
 286                 b = (value == TRUE);
 287
 288                 return ret;
 289         }
 290 #endif
 291
 292 private:
 293         CAutoConfig(const CAutoConfig&) = delete;
 294         CAutoConfig& operator=(const CAutoConfig&) = delete;
 295 };