src/Utils/SmartLibgit2Ref.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2014-2015 - 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, class FreeFunction>
  28 class CSmartBuffer : public FreeFunction
  29 {
  30 public:
  31         CSmartBuffer()
  32         {
  33                 HandleType tmp = { 0 };
  34                 m_Ref = tmp;
  35         }
  36
  37         operator HandleType*()
  38         {
  39                 return &m_Ref;
  40         }
  41
  42         HandleType* operator->()
  43         {
  44                 return &m_Ref;
  45         }
  46
  47         ~CSmartBuffer()
  48         {
  49                 Free(&m_Ref);
  50         }
  51
  52 private:
  53         CSmartBuffer(const CSmartBuffer& that);
  54         CSmartBuffer& operator=(const CSmartBuffer& that);
  55
  56 protected:
  57         HandleType m_Ref;
  58 };
  59
  60 struct CFreeBuf
  61 {
  62 protected:
  63         void Free(git_buf* ref)
  64         {
  65                 git_buf_free(ref);
  66         }
  67
  68         ~CFreeBuf()
  69         {
  70         }
  71 };
  72
  73 struct CFreeStrArray
  74 {
  75 protected:
  76         void Free(git_strarray* ref)
  77         {
  78                 git_strarray_free(ref);
  79         }
  80
  81         ~CFreeStrArray()
  82         {
  83         }
  84 };
  85
  86 typedef CSmartBuffer<git_buf, CFreeBuf> CAutoBuf;
  87 typedef CSmartBuffer<git_strarray, CFreeStrArray>       CAutoStrArray;
  88
  89 template <typename ReferenceType>
  90 class CSmartLibgit2Ref
  91 {
  92 public:
  93         CSmartLibgit2Ref()
  94         {
  95                 m_Ref = nullptr;
  96         }
  97
  98         void Swap(CSmartLibgit2Ref& tmp)
  99         {
 100                 ReferenceType* p;
 101
 102                 p = m_Ref;
 103                 m_Ref = tmp.m_Ref;
 104                 tmp.m_Ref = p;
 105         }
 106
 107         void Free()
 108         {
 109                 CleanUp();
 110         }
 111
 112         ReferenceType* Detach()
 113         {
 114                 ReferenceType* p;
 115
 116                 p = m_Ref;
 117                 m_Ref = nullptr;
 118
 119                 return p;
 120         }
 121
 122         operator ReferenceType*()
 123         {
 124                 return m_Ref;
 125         }
 126
 127         /**
 128          * Free the wrapped object and return a pointer to the wrapped object ReferenceType*
 129          */
 130         ReferenceType** GetPointer()
 131         {
 132                 CleanUp();
 133                 return &m_Ref;
 134         }
 135
 136         operator bool()
 137         {
 138                 return IsValid();
 139         }
 140
 141         bool IsValid() const
 142         {
 143                 return m_Ref != nullptr;
 144         }
 145
 146 private:
 147         CSmartLibgit2Ref(const CSmartLibgit2Ref& that);
 148         CSmartLibgit2Ref& operator=(const CSmartLibgit2Ref& that);
 149
 150 protected:
 151         virtual void FreeRef() = 0;
 152
 153         void CleanUp()
 154         {
 155                 if (IsValid())
 156                 {
 157                         FreeRef();
 158                         m_Ref = nullptr;
 159                 }
 160         }
 161
 162         ReferenceType* m_Ref;
 163 };
 164
 165 class CAutoRepository : public CSmartLibgit2Ref<git_repository>
 166 {
 167 public:
 168         CAutoRepository() {};
 169
 170         CAutoRepository(git_repository* h)
 171         {
 172                 m_Ref = h;
 173         }
 174
 175         CAutoRepository(const CString& gitDir)
 176         {
 177                 Open(gitDir);
 178         }
 179
 180         CAutoRepository(const CStringA& gitDirA)
 181         {
 182                 Open(gitDirA);
 183         }
 184
 185         int Open(const CString& gitDir)
 186         {
 187                 return Open(CUnicodeUtils::GetUTF8(gitDir));
 188         }
 189
 190         int Open(const CStringA& gitDirA)
 191         {
 192                 CleanUp();
 193                 return git_repository_open(GetPointer(), gitDirA);
 194         }
 195
 196         ~CAutoRepository()
 197         {
 198                 CleanUp();
 199         }
 200
 201 protected:
 202         virtual void FreeRef()
 203         {
 204                 git_repository_free(m_Ref);
 205         }
 206 };
 207
 208 class CAutoCommit : public CSmartLibgit2Ref<git_commit>
 209 {
 210 public:
 211         CAutoCommit() {}
 212
 213         CAutoCommit(git_commit* h)
 214         {
 215                 m_Ref = h;
 216         }
 217
 218         ~CAutoCommit()
 219         {
 220                 CleanUp();
 221         }
 222 protected:
 223         virtual void FreeRef()
 224         {
 225                 git_commit_free(m_Ref);
 226         }
 227 };
 228
 229 class CAutoTree : public CSmartLibgit2Ref<git_tree>
 230 {
 231 public:
 232         git_tree* operator=(git_tree* h)
 233         {
 234                 if (m_Ref != h)
 235                 {
 236                         CleanUp();
 237                         m_Ref = h;
 238                 }
 239                 return (*this);
 240         }
 241
 242         ~CAutoTree()
 243         {
 244                 CleanUp();
 245         }
 246
 247 protected:
 248         virtual void FreeRef()
 249         {
 250                 git_tree_free(m_Ref);
 251         }
 252 };
 253
 254 class CAutoObject : public CSmartLibgit2Ref<git_object>
 255 {
 256 public:
 257         ~CAutoObject()
 258         {
 259                 CleanUp();
 260         }
 261
 262 protected:
 263         virtual void FreeRef()
 264         {
 265                 git_object_free(m_Ref);
 266         }
 267 };
 268
 269 class CAutoBlob : public CSmartLibgit2Ref<git_blob>
 270 {
 271 public:
 272         ~CAutoBlob()
 273         {
 274                 CleanUp();
 275         }
 276
 277 protected:
 278         virtual void FreeRef()
 279         {
 280                 git_blob_free(m_Ref);
 281         }
 282 };
 283
 284 class CAutoConfig : public CSmartLibgit2Ref<git_config>
 285 {
 286 public:
 287         CAutoConfig() {}
 288
 289         CAutoConfig(CAutoRepository &repo)
 290         {
 291                 git_repository_config(&m_Ref, repo);
 292         }
 293
 294         CAutoConfig(bool init)
 295         {
 296                 if (init)
 297                         New();
 298         }
 299
 300         void New()
 301         {
 302                 CleanUp();
 303                 git_config_new(&m_Ref);
 304         }
 305
 306         ~CAutoConfig()
 307         {
 308                 CleanUp();
 309         }
 310
 311         int GetString(const CString &key, CString &value) const
 312         {
 313                 if (!IsValid())
 314                         return -1;
 315
 316                 CAutoBuf buf;
 317                 int ret = 0;
 318                 if ((ret = git_config_get_string_buf(buf, m_Ref, CUnicodeUtils::GetUTF8(key))))
 319                 {
 320                         value.Empty();
 321                         return ret;
 322                 }
 323
 324                 value = CUnicodeUtils::GetUnicode((CStringA)buf->ptr);
 325
 326                 return ret;
 327         }
 328
 329         int GetBOOL(const CString &key, BOOL &b) const
 330         {
 331                 if (!IsValid())
 332                         return -1;
 333
 334                 return git_config_get_bool(&b, m_Ref, CUnicodeUtils::GetUTF8(key));
 335         }
 336
 337         int GetBool(const CString &key, bool &b) const
 338         {
 339                 if (!IsValid())
 340                         return -1;
 341
 342                 int value = FALSE;
 343                 int ret = 0;
 344                 if ((ret = GetBOOL(key, value)) < 0)
 345                         return ret;
 346
 347                 b = (value == TRUE);
 348
 349                 return ret;
 350         }
 351
 352 protected:
 353         virtual void FreeRef()
 354         {
 355                 git_config_free(m_Ref);
 356         }
 357 };
 358
 359 class CAutoReference : public CSmartLibgit2Ref<git_reference>
 360 {
 361 public:
 362         CAutoReference() {}
 363
 364         CAutoReference(git_reference* h)
 365         {
 366                 m_Ref = h;
 367         }
 368
 369         ~CAutoReference()
 370         {
 371                 CleanUp();
 372         }
 373
 374 protected:
 375         virtual void FreeRef()
 376         {
 377                 git_reference_free(m_Ref);
 378         }
 379 };
 380
 381 class CAutoTreeEntry : public CSmartLibgit2Ref<git_tree_entry>
 382 {
 383 public:
 384         ~CAutoTreeEntry()
 385         {
 386                 CleanUp();
 387         }
 388
 389 protected:
 390         virtual void FreeRef()
 391         {
 392                 git_tree_entry_free(m_Ref);
 393         }
 394 };
 395
 396 class CAutoDiff : public CSmartLibgit2Ref<git_diff>
 397 {
 398 public:
 399         ~CAutoDiff()
 400         {
 401                 CleanUp();
 402         }
 403
 404 protected:
 405         virtual void FreeRef()
 406         {
 407                 git_diff_free(m_Ref);
 408         }
 409 };
 410
 411 class CAutoPatch : public CSmartLibgit2Ref<git_patch>
 412 {
 413 public:
 414         ~CAutoPatch()
 415         {
 416                 CleanUp();
 417         }
 418
 419 protected:
 420         virtual void FreeRef()
 421         {
 422                 git_patch_free(m_Ref);
 423         }
 424 };
 425
 426 class CAutoDiffStats : public CSmartLibgit2Ref<git_diff_stats>
 427 {
 428 public:
 429         ~CAutoDiffStats()
 430         {
 431                 CleanUp();
 432         }
 433
 434 protected:
 435         virtual void FreeRef()
 436         {
 437                 git_diff_stats_free(m_Ref);
 438         }
 439 };
 440
 441 class CAutoIndex : public CSmartLibgit2Ref<git_index>
 442 {
 443 public:
 444         ~CAutoIndex()
 445         {
 446                 CleanUp();
 447         }
 448
 449 protected:
 450         virtual void FreeRef()
 451         {
 452                 git_index_free(m_Ref);
 453         }
 454 };
 455
 456 class CAutoRemote : public CSmartLibgit2Ref<git_remote>
 457 {
 458 public:
 459         ~CAutoRemote()
 460         {
 461                 CleanUp();
 462         }
 463
 464 protected:
 465         virtual void FreeRef()
 466         {
 467                 git_remote_free(m_Ref);
 468         }
 469 };
 470
 471 class CAutoReflog : public CSmartLibgit2Ref<git_reflog>
 472 {
 473 public:
 474         ~CAutoReflog()
 475         {
 476                 CleanUp();
 477         }
 478
 479 protected:
 480         virtual void FreeRef()
 481         {
 482                 git_reflog_free(m_Ref);
 483         }
 484 };
 485
 486 class CAutoRevwalk : public CSmartLibgit2Ref<git_revwalk>
 487 {
 488 public:
 489         ~CAutoRevwalk()
 490         {
 491                 CleanUp();
 492         }
 493
 494 protected:
 495         virtual void FreeRef()
 496         {
 497                 git_revwalk_free(m_Ref);
 498         }
 499 };
 500
 501 class CAutoBranchIterator : public CSmartLibgit2Ref<git_branch_iterator>
 502 {
 503 public:
 504         ~CAutoBranchIterator()
 505         {
 506                 CleanUp();
 507         }
 508
 509 protected:
 510         virtual void FreeRef()
 511         {
 512                 git_branch_iterator_free(m_Ref);
 513         }
 514 };
 515
 516 class CAutoDescribeResult : public CSmartLibgit2Ref<git_describe_result>
 517 {
 518 public:
 519         ~CAutoDescribeResult()
 520         {
 521                 CleanUp();
 522         }
 523
 524 protected:
 525         virtual void FreeRef()
 526         {
 527                 git_describe_result_free(m_Ref);
 528         }
 529 };
 530
 531 class CAutoStatusList : public CSmartLibgit2Ref<git_status_list>
 532 {
 533 public:
 534         ~CAutoStatusList()
 535         {
 536                 CleanUp();
 537         }
 538 protected:
 539         virtual void FreeRef()
 540         {
 541                 git_status_list_free(m_Ref);
 542         }
 543 };