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 private:
 202         CAutoRepository(const CAutoRepository& that);
 203         CAutoRepository& operator=(const CAutoRepository& that);
 204
 205 protected:
 206         virtual void FreeRef()
 207         {
 208                 git_repository_free(m_Ref);
 209         }
 210 };
 211
 212 class CAutoSubmodule : public CSmartLibgit2Ref<git_submodule>
 213 {
 214 public:
 215         CAutoSubmodule() {};
 216
 217         ~CAutoSubmodule()
 218         {
 219                 CleanUp();
 220         }
 221
 222 private:
 223         CAutoSubmodule(const CAutoSubmodule& that);
 224         CAutoSubmodule& operator=(const CAutoSubmodule& that);
 225
 226 protected:
 227         virtual void FreeRef()
 228         {
 229                 git_submodule_free(m_Ref);
 230         }
 231 };
 232
 233 class CAutoCommit : public CSmartLibgit2Ref<git_commit>
 234 {
 235 public:
 236         CAutoCommit() {}
 237
 238         CAutoCommit(git_commit* h)
 239         {
 240                 m_Ref = h;
 241         }
 242
 243         ~CAutoCommit()
 244         {
 245                 CleanUp();
 246         }
 247
 248 private:
 249         CAutoCommit(const CAutoCommit& that);
 250         CAutoCommit& operator=(const CAutoCommit& that);
 251
 252 protected:
 253         virtual void FreeRef()
 254         {
 255                 git_commit_free(m_Ref);
 256         }
 257 };
 258
 259 class CAutoTree : public CSmartLibgit2Ref<git_tree>
 260 {
 261 public:
 262         CAutoTree() {};
 263
 264         git_tree* operator=(git_tree* h)
 265         {
 266                 if (m_Ref != h)
 267                 {
 268                         CleanUp();
 269                         m_Ref = h;
 270                 }
 271                 return (*this);
 272         }
 273
 274         ~CAutoTree()
 275         {
 276                 CleanUp();
 277         }
 278
 279 private:
 280         CAutoTree(const CAutoTree& that);
 281         CAutoTree& operator=(const CAutoTree& that);
 282
 283 protected:
 284         virtual void FreeRef()
 285         {
 286                 git_tree_free(m_Ref);
 287         }
 288 };
 289
 290 class CAutoObject : public CSmartLibgit2Ref<git_object>
 291 {
 292 public:
 293         CAutoObject() {};
 294
 295         ~CAutoObject()
 296         {
 297                 CleanUp();
 298         }
 299
 300 private:
 301         CAutoObject(const CAutoObject& that);
 302         CAutoObject& operator=(const CAutoObject& that);
 303
 304 protected:
 305         virtual void FreeRef()
 306         {
 307                 git_object_free(m_Ref);
 308         }
 309 };
 310
 311 class CAutoBlob : public CSmartLibgit2Ref<git_blob>
 312 {
 313 public:
 314         CAutoBlob() {};
 315
 316         ~CAutoBlob()
 317         {
 318                 CleanUp();
 319         }
 320
 321 private:
 322         CAutoBlob(const CAutoBlob& that);
 323         CAutoBlob& operator=(const CAutoBlob& that);
 324
 325 protected:
 326         virtual void FreeRef()
 327         {
 328                 git_blob_free(m_Ref);
 329         }
 330 };
 331
 332 class CAutoConfig : public CSmartLibgit2Ref<git_config>
 333 {
 334 public:
 335         CAutoConfig() {}
 336
 337         CAutoConfig(CAutoRepository &repo)
 338         {
 339                 git_repository_config(&m_Ref, repo);
 340         }
 341
 342         CAutoConfig(bool init)
 343         {
 344                 if (init)
 345                         New();
 346         }
 347
 348         void New()
 349         {
 350                 CleanUp();
 351                 git_config_new(&m_Ref);
 352         }
 353
 354         ~CAutoConfig()
 355         {
 356                 CleanUp();
 357         }
 358
 359         int GetString(const CString &key, CString &value) const
 360         {
 361                 if (!IsValid())
 362                         return -1;
 363
 364                 CAutoBuf buf;
 365                 int ret = 0;
 366                 if ((ret = git_config_get_string_buf(buf, m_Ref, CUnicodeUtils::GetUTF8(key))))
 367                 {
 368                         value.Empty();
 369                         return ret;
 370                 }
 371
 372                 value = CUnicodeUtils::GetUnicode((CStringA)buf->ptr);
 373
 374                 return ret;
 375         }
 376
 377         int GetBOOL(const CString &key, BOOL &b) const
 378         {
 379                 if (!IsValid())
 380                         return -1;
 381
 382                 return git_config_get_bool(&b, m_Ref, CUnicodeUtils::GetUTF8(key));
 383         }
 384
 385         int GetBool(const CString &key, bool &b) const
 386         {
 387                 if (!IsValid())
 388                         return -1;
 389
 390                 int value = FALSE;
 391                 int ret = 0;
 392                 if ((ret = GetBOOL(key, value)) < 0)
 393                         return ret;
 394
 395                 b = (value == TRUE);
 396
 397                 return ret;
 398         }
 399
 400 private:
 401         CAutoConfig(const CAutoConfig& that);
 402         CAutoConfig& operator=(const CAutoConfig& that);
 403
 404 protected:
 405         virtual void FreeRef()
 406         {
 407                 git_config_free(m_Ref);
 408         }
 409 };
 410
 411 class CAutoReference : public CSmartLibgit2Ref<git_reference>
 412 {
 413 public:
 414         CAutoReference() {}
 415
 416         CAutoReference(git_reference* h)
 417         {
 418                 m_Ref = h;
 419         }
 420
 421         ~CAutoReference()
 422         {
 423                 CleanUp();
 424         }
 425
 426 private:
 427         CAutoReference(const CAutoReference& that);
 428         CAutoReference& operator=(const CAutoReference& that);
 429
 430 protected:
 431         virtual void FreeRef()
 432         {
 433                 git_reference_free(m_Ref);
 434         }
 435 };
 436
 437 class CAutoTreeEntry : public CSmartLibgit2Ref<git_tree_entry>
 438 {
 439 public:
 440         CAutoTreeEntry() {};
 441
 442         ~CAutoTreeEntry()
 443         {
 444                 CleanUp();
 445         }
 446
 447 private:
 448         CAutoTreeEntry(const CAutoTreeEntry& that);
 449         CAutoTreeEntry& operator=(const CAutoTreeEntry& that);
 450
 451 protected:
 452         virtual void FreeRef()
 453         {
 454                 git_tree_entry_free(m_Ref);
 455         }
 456 };
 457
 458 class CAutoDiff : public CSmartLibgit2Ref<git_diff>
 459 {
 460 public:
 461         CAutoDiff() {};
 462
 463         ~CAutoDiff()
 464         {
 465                 CleanUp();
 466         }
 467
 468 private:
 469         CAutoDiff(const CAutoDiff& that);
 470         CAutoDiff& operator=(const CAutoDiff& that);
 471
 472 protected:
 473         virtual void FreeRef()
 474         {
 475                 git_diff_free(m_Ref);
 476         }
 477 };
 478
 479 class CAutoPatch : public CSmartLibgit2Ref<git_patch>
 480 {
 481 public:
 482         CAutoPatch() {};
 483
 484         ~CAutoPatch()
 485         {
 486                 CleanUp();
 487         }
 488
 489 private:
 490         CAutoPatch(const CAutoPatch& that);
 491         CAutoPatch& operator=(const CAutoPatch& that);
 492
 493 protected:
 494         virtual void FreeRef()
 495         {
 496                 git_patch_free(m_Ref);
 497         }
 498 };
 499
 500 class CAutoDiffStats : public CSmartLibgit2Ref<git_diff_stats>
 501 {
 502 public:
 503         CAutoDiffStats() {};
 504
 505         ~CAutoDiffStats()
 506         {
 507                 CleanUp();
 508         }
 509
 510 private:
 511         CAutoDiffStats(const CAutoDiffStats& that);
 512         CAutoDiffStats& operator=(const CAutoDiffStats& that);
 513
 514 protected:
 515         virtual void FreeRef()
 516         {
 517                 git_diff_stats_free(m_Ref);
 518         }
 519 };
 520
 521 class CAutoIndex : public CSmartLibgit2Ref<git_index>
 522 {
 523 public:
 524         CAutoIndex() {};
 525
 526         ~CAutoIndex()
 527         {
 528                 CleanUp();
 529         }
 530
 531 private:
 532         CAutoIndex(const CAutoIndex& that);
 533         CAutoIndex& operator=(const CAutoIndex& that);
 534
 535 protected:
 536         virtual void FreeRef()
 537         {
 538                 git_index_free(m_Ref);
 539         }
 540 };
 541
 542 class CAutoRemote : public CSmartLibgit2Ref<git_remote>
 543 {
 544 public:
 545         CAutoRemote() {};
 546
 547         ~CAutoRemote()
 548         {
 549                 CleanUp();
 550         }
 551
 552 private:
 553         CAutoRemote(const CAutoRemote& that);
 554         CAutoRemote& operator=(const CAutoRemote& that);
 555
 556 protected:
 557         virtual void FreeRef()
 558         {
 559                 git_remote_free(m_Ref);
 560         }
 561 };
 562
 563 class CAutoReflog : public CSmartLibgit2Ref<git_reflog>
 564 {
 565 public:
 566         CAutoReflog() {};
 567
 568         ~CAutoReflog()
 569         {
 570                 CleanUp();
 571         }
 572
 573 private:
 574         CAutoReflog(const CAutoReflog& that);
 575         CAutoReflog& operator=(const CAutoReflog& that);
 576
 577 protected:
 578         virtual void FreeRef()
 579         {
 580                 git_reflog_free(m_Ref);
 581         }
 582 };
 583
 584 class CAutoRevwalk : public CSmartLibgit2Ref<git_revwalk>
 585 {
 586 public:
 587         CAutoRevwalk() {};
 588
 589         ~CAutoRevwalk()
 590         {
 591                 CleanUp();
 592         }
 593
 594 private:
 595         CAutoRevwalk(const CAutoRevwalk& that);
 596         CAutoRevwalk& operator=(const CAutoRevwalk& that);
 597
 598 protected:
 599         virtual void FreeRef()
 600         {
 601                 git_revwalk_free(m_Ref);
 602         }
 603 };
 604
 605 class CAutoBranchIterator : public CSmartLibgit2Ref<git_branch_iterator>
 606 {
 607 public:
 608         CAutoBranchIterator() {};
 609
 610         ~CAutoBranchIterator()
 611         {
 612                 CleanUp();
 613         }
 614
 615 private:
 616         CAutoBranchIterator(const CAutoBranchIterator& that) ;
 617         CAutoBranchIterator& operator=(const CAutoBranchIterator& that);
 618
 619 protected:
 620         virtual void FreeRef()
 621         {
 622                 git_branch_iterator_free(m_Ref);
 623         }
 624 };
 625
 626 class CAutoDescribeResult : public CSmartLibgit2Ref<git_describe_result>
 627 {
 628 public:
 629         CAutoDescribeResult() {};
 630
 631         ~CAutoDescribeResult()
 632         {
 633                 CleanUp();
 634         }
 635
 636 private:
 637         CAutoDescribeResult(const CAutoDescribeResult& that);
 638         CAutoDescribeResult& operator=(const CAutoDescribeResult& that);
 639
 640 protected:
 641         virtual void FreeRef()
 642         {
 643                 git_describe_result_free(m_Ref);
 644         }
 645 };
 646
 647 class CAutoStatusList : public CSmartLibgit2Ref<git_status_list>
 648 {
 649 public:
 650         CAutoStatusList() {};
 651
 652         ~CAutoStatusList()
 653         {
 654                 CleanUp();
 655         }
 656
 657 private:
 658         CAutoStatusList(const CAutoStatusList& that);
 659         CAutoStatusList& operator=(const CAutoStatusList& that);
 660
 661 protected:
 662         virtual void FreeRef()
 663         {
 664                 git_status_list_free(m_Ref);
 665         }
 666 };