src/Utils/SmartLibgit2Ref.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2014-2016 - 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
  29 {
  30 public:
  31         CSmartBuffer()
  32         {
  33                 m_Ref = { 0 };
  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::Free(&m_Ref);
  49         }
  50
  51 private:
  52         CSmartBuffer(const CSmartBuffer&) = delete;
  53         CSmartBuffer& operator=(const CSmartBuffer&) = delete;
  54
  55 protected:
  56         HandleType m_Ref;
  57 };
  58
  59 struct CFreeBuf
  60 {
  61         static void Free(git_buf* ref)
  62         {
  63                 git_buf_free(ref);
  64         }
  65 };
  66
  67 struct CFreeStrArray
  68 {
  69         static void Free(git_strarray* ref)
  70         {
  71                 git_strarray_free(ref);
  72         }
  73 };
  74
  75 typedef CSmartBuffer<git_buf, CFreeBuf> CAutoBuf;
  76 typedef CSmartBuffer<git_strarray, CFreeStrArray>       CAutoStrArray;
  77
  78 template <typename ReferenceType>
  79 class CSmartLibgit2Ref
  80 {
  81 public:
  82         CSmartLibgit2Ref()
  83         {
  84                 m_Ref = nullptr;
  85         }
  86
  87         void Swap(CSmartLibgit2Ref& tmp)
  88         {
  89                 ReferenceType* p;
  90
  91                 p = m_Ref;
  92                 m_Ref = tmp.m_Ref;
  93                 tmp.m_Ref = p;
  94         }
  95
  96         void Free()
  97         {
  98                 CleanUp();
  99         }
 100
 101         ReferenceType* Detach()
 102         {
 103                 ReferenceType* p = m_Ref;
 104                 m_Ref = nullptr;
 105
 106                 return p;
 107         }
 108
 109         operator ReferenceType*() const
 110         {
 111                 return m_Ref;
 112         }
 113
 114         /**
 115          * Free the wrapped object and return a pointer to the wrapped object ReferenceType*
 116          */
 117         ReferenceType** GetPointer()
 118         {
 119                 CleanUp();
 120                 return &m_Ref;
 121         }
 122
 123         operator bool() const
 124         {
 125                 return IsValid();
 126         }
 127
 128         bool IsValid() const
 129         {
 130                 return m_Ref != nullptr;
 131         }
 132
 133 private:
 134         CSmartLibgit2Ref(const CSmartLibgit2Ref&) = delete;
 135         CSmartLibgit2Ref& operator=(const CSmartLibgit2Ref&) = delete;
 136
 137 protected:
 138         virtual void FreeRef() = 0;
 139
 140         void CleanUp()
 141         {
 142                 if (IsValid())
 143                 {
 144                         FreeRef();
 145                         m_Ref = nullptr;
 146                 }
 147         }
 148
 149         ReferenceType* m_Ref;
 150 };
 151
 152 class CAutoRepository : public CSmartLibgit2Ref<git_repository>
 153 {
 154 public:
 155         CAutoRepository() {};
 156
 157         CAutoRepository(git_repository* h)
 158         {
 159                 m_Ref = h;
 160         }
 161
 162         CAutoRepository(const CString& gitDir)
 163         {
 164                 Open(gitDir);
 165         }
 166
 167         CAutoRepository(const CStringA& gitDirA)
 168         {
 169                 Open(gitDirA);
 170         }
 171
 172         CAutoRepository(CAutoRepository&& that)
 173         {
 174                 m_Ref = that.Detach();
 175         }
 176
 177         int Open(const CString& gitDir)
 178         {
 179                 return Open(CUnicodeUtils::GetUTF8(gitDir));
 180         }
 181
 182         ~CAutoRepository()
 183         {
 184                 CleanUp();
 185         }
 186
 187 private:
 188         CAutoRepository(const CAutoRepository&) = delete;
 189         CAutoRepository& operator=(const CAutoRepository&) = delete;
 190
 191 protected:
 192         int Open(const CStringA& gitDirA)
 193         {
 194                 return git_repository_open(GetPointer(), gitDirA);
 195         }
 196
 197         virtual void FreeRef()
 198         {
 199                 git_repository_free(m_Ref);
 200         }
 201 };
 202
 203 class CAutoSubmodule : public CSmartLibgit2Ref<git_submodule>
 204 {
 205 public:
 206         CAutoSubmodule() {};
 207
 208         ~CAutoSubmodule()
 209         {
 210                 CleanUp();
 211         }
 212
 213 private:
 214         CAutoSubmodule(const CAutoSubmodule&) = delete;
 215         CAutoSubmodule& operator=(const CAutoSubmodule&) = delete;
 216
 217 protected:
 218         virtual void FreeRef()
 219         {
 220                 git_submodule_free(m_Ref);
 221         }
 222 };
 223
 224 class CAutoCommit : public CSmartLibgit2Ref<git_commit>
 225 {
 226 public:
 227         CAutoCommit() {}
 228
 229         CAutoCommit(git_commit* h)
 230         {
 231                 m_Ref = h;
 232         }
 233
 234         ~CAutoCommit()
 235         {
 236                 CleanUp();
 237         }
 238
 239 private:
 240         CAutoCommit(const CAutoCommit&) = delete;
 241         CAutoCommit& operator=(const CAutoCommit&) = delete;
 242
 243 protected:
 244         virtual void FreeRef()
 245         {
 246                 git_commit_free(m_Ref);
 247         }
 248 };
 249
 250 class CAutoTree : public CSmartLibgit2Ref<git_tree>
 251 {
 252 public:
 253         CAutoTree() {};
 254
 255         git_tree* operator=(git_tree* h)
 256         {
 257                 if (m_Ref != h)
 258                 {
 259                         CleanUp();
 260                         m_Ref = h;
 261                 }
 262                 return (*this);
 263         }
 264
 265         ~CAutoTree()
 266         {
 267                 CleanUp();
 268         }
 269
 270 private:
 271         CAutoTree(const CAutoTree&) = delete;
 272         CAutoTree& operator=(const CAutoTree&) = delete;
 273
 274 protected:
 275         virtual void FreeRef()
 276         {
 277                 git_tree_free(m_Ref);
 278         }
 279 };
 280
 281 class CAutoObject : public CSmartLibgit2Ref<git_object>
 282 {
 283 public:
 284         CAutoObject() {};
 285
 286         ~CAutoObject()
 287         {
 288                 CleanUp();
 289         }
 290
 291 private:
 292         CAutoObject(const CAutoObject&) = delete;
 293         CAutoObject& operator=(const CAutoObject&) = delete;
 294
 295 protected:
 296         virtual void FreeRef()
 297         {
 298                 git_object_free(m_Ref);
 299         }
 300 };
 301
 302 class CAutoBlob : public CSmartLibgit2Ref<git_blob>
 303 {
 304 public:
 305         CAutoBlob() {};
 306
 307         ~CAutoBlob()
 308         {
 309                 CleanUp();
 310         }
 311
 312 private:
 313         CAutoBlob(const CAutoBlob&) = delete;
 314         CAutoBlob& operator=(const CAutoBlob&) = delete;
 315
 316 protected:
 317         virtual void FreeRef()
 318         {
 319                 git_blob_free(m_Ref);
 320         }
 321 };
 322
 323 class CAutoConfig : public CSmartLibgit2Ref<git_config>
 324 {
 325 public:
 326         CAutoConfig() {}
 327
 328         CAutoConfig(CAutoRepository &repo)
 329         {
 330                 git_repository_config(&m_Ref, repo);
 331         }
 332
 333         CAutoConfig(bool init)
 334         {
 335                 if (init)
 336                         New();
 337         }
 338
 339         void New()
 340         {
 341                 CleanUp();
 342                 git_config_new(&m_Ref);
 343         }
 344
 345         ~CAutoConfig()
 346         {
 347                 CleanUp();
 348         }
 349
 350         int GetString(const CString &key, CString &value) const
 351         {
 352                 if (!IsValid())
 353                         return -1;
 354
 355                 CAutoBuf buf;
 356                 int ret = 0;
 357                 if ((ret = git_config_get_string_buf(buf, m_Ref, CUnicodeUtils::GetUTF8(key))))
 358                 {
 359                         value.Empty();
 360                         return ret;
 361                 }
 362
 363                 value = CUnicodeUtils::GetUnicode((CStringA)buf->ptr);
 364
 365                 return ret;
 366         }
 367
 368         int GetBOOL(const CString &key, BOOL &b) const
 369         {
 370                 if (!IsValid())
 371                         return -1;
 372
 373                 return git_config_get_bool(&b, m_Ref, CUnicodeUtils::GetUTF8(key));
 374         }
 375
 376         int GetBool(const CString &key, bool &b) const
 377         {
 378                 if (!IsValid())
 379                         return -1;
 380
 381                 int value = FALSE;
 382                 int ret = 0;
 383                 if ((ret = GetBOOL(key, value)) < 0)
 384                         return ret;
 385
 386                 b = (value == TRUE);
 387
 388                 return ret;
 389         }
 390
 391 private:
 392         CAutoConfig(const CAutoConfig&) = delete;
 393         CAutoConfig& operator=(const CAutoConfig&) = delete;
 394
 395 protected:
 396         virtual void FreeRef()
 397         {
 398                 git_config_free(m_Ref);
 399         }
 400 };
 401
 402 class CAutoReference : public CSmartLibgit2Ref<git_reference>
 403 {
 404 public:
 405         CAutoReference() {}
 406
 407         CAutoReference(git_reference* h)
 408         {
 409                 m_Ref = h;
 410         }
 411
 412         ~CAutoReference()
 413         {
 414                 CleanUp();
 415         }
 416
 417 private:
 418         CAutoReference(const CAutoReference&) = delete;
 419         CAutoReference& operator=(const CAutoReference&) = delete;
 420
 421 protected:
 422         virtual void FreeRef()
 423         {
 424                 git_reference_free(m_Ref);
 425         }
 426 };
 427
 428 class CAutoTag : public CSmartLibgit2Ref<git_tag>
 429 {
 430 public:
 431         CAutoTag() {}
 432
 433         CAutoTag(git_tag* h)
 434         {
 435                 m_Ref = h;
 436         }
 437
 438         ~CAutoTag()
 439         {
 440                 CleanUp();
 441         }
 442
 443 private:
 444         CAutoTag(const CAutoTag&) = delete;
 445         CAutoTag& operator=(const CAutoTag&) = delete;
 446
 447 protected:
 448         virtual void FreeRef()
 449         {
 450                 git_tag_free(m_Ref);
 451         }
 452 };
 453
 454 class CAutoTreeEntry : public CSmartLibgit2Ref<git_tree_entry>
 455 {
 456 public:
 457         CAutoTreeEntry() {};
 458
 459         ~CAutoTreeEntry()
 460         {
 461                 CleanUp();
 462         }
 463
 464 private:
 465         CAutoTreeEntry(const CAutoTreeEntry&) = delete;
 466         CAutoTreeEntry& operator=(const CAutoTreeEntry&) = delete;
 467
 468 protected:
 469         virtual void FreeRef()
 470         {
 471                 git_tree_entry_free(m_Ref);
 472         }
 473 };
 474
 475 class CAutoDiff : public CSmartLibgit2Ref<git_diff>
 476 {
 477 public:
 478         CAutoDiff() {};
 479
 480         ~CAutoDiff()
 481         {
 482                 CleanUp();
 483         }
 484
 485 private:
 486         CAutoDiff(const CAutoDiff&) = delete;
 487         CAutoDiff& operator=(const CAutoDiff&) = delete;
 488
 489 protected:
 490         virtual void FreeRef()
 491         {
 492                 git_diff_free(m_Ref);
 493         }
 494 };
 495
 496 class CAutoPatch : public CSmartLibgit2Ref<git_patch>
 497 {
 498 public:
 499         CAutoPatch() {};
 500
 501         ~CAutoPatch()
 502         {
 503                 CleanUp();
 504         }
 505
 506 private:
 507         CAutoPatch(const CAutoPatch&) = delete;
 508         CAutoPatch& operator=(const CAutoPatch&) = delete;
 509
 510 protected:
 511         virtual void FreeRef()
 512         {
 513                 git_patch_free(m_Ref);
 514         }
 515 };
 516
 517 class CAutoDiffStats : public CSmartLibgit2Ref<git_diff_stats>
 518 {
 519 public:
 520         CAutoDiffStats() {};
 521
 522         ~CAutoDiffStats()
 523         {
 524                 CleanUp();
 525         }
 526
 527 private:
 528         CAutoDiffStats(const CAutoDiffStats&) = delete;
 529         CAutoDiffStats& operator=(const CAutoDiffStats&) = delete;
 530
 531 protected:
 532         virtual void FreeRef()
 533         {
 534                 git_diff_stats_free(m_Ref);
 535         }
 536 };
 537
 538 class CAutoIndex : public CSmartLibgit2Ref<git_index>
 539 {
 540 public:
 541         CAutoIndex() {};
 542
 543         ~CAutoIndex()
 544         {
 545                 CleanUp();
 546         }
 547
 548 private:
 549         CAutoIndex(const CAutoIndex& that);
 550         CAutoIndex& operator=(const CAutoIndex& that);
 551
 552 protected:
 553         virtual void FreeRef()
 554         {
 555                 git_index_free(m_Ref);
 556         }
 557 };
 558
 559 class CAutoRemote : public CSmartLibgit2Ref<git_remote>
 560 {
 561 public:
 562         CAutoRemote() {};
 563
 564         ~CAutoRemote()
 565         {
 566                 CleanUp();
 567         }
 568
 569 private:
 570         CAutoRemote(const CAutoRemote&) = delete;
 571         CAutoRemote& operator=(const CAutoRemote&) = delete;
 572
 573 protected:
 574         virtual void FreeRef()
 575         {
 576                 git_remote_free(m_Ref);
 577         }
 578 };
 579
 580 class CAutoReflog : public CSmartLibgit2Ref<git_reflog>
 581 {
 582 public:
 583         CAutoReflog() {};
 584
 585         ~CAutoReflog()
 586         {
 587                 CleanUp();
 588         }
 589
 590 private:
 591         CAutoReflog(const CAutoReflog&) = delete;
 592         CAutoReflog& operator=(const CAutoReflog&) = delete;
 593
 594 protected:
 595         virtual void FreeRef()
 596         {
 597                 git_reflog_free(m_Ref);
 598         }
 599 };
 600
 601 class CAutoRevwalk : public CSmartLibgit2Ref<git_revwalk>
 602 {
 603 public:
 604         CAutoRevwalk() {};
 605
 606         ~CAutoRevwalk()
 607         {
 608                 CleanUp();
 609         }
 610
 611 private:
 612         CAutoRevwalk(const CAutoRevwalk&) = delete;
 613         CAutoRevwalk& operator=(const CAutoRevwalk&) = delete;
 614
 615 protected:
 616         virtual void FreeRef()
 617         {
 618                 git_revwalk_free(m_Ref);
 619         }
 620 };
 621
 622 class CAutoBranchIterator : public CSmartLibgit2Ref<git_branch_iterator>
 623 {
 624 public:
 625         CAutoBranchIterator() {};
 626
 627         ~CAutoBranchIterator()
 628         {
 629                 CleanUp();
 630         }
 631
 632 private:
 633         CAutoBranchIterator(const CAutoBranchIterator&) = delete;
 634         CAutoBranchIterator& operator=(const CAutoBranchIterator&) = delete;
 635
 636 protected:
 637         virtual void FreeRef()
 638         {
 639                 git_branch_iterator_free(m_Ref);
 640         }
 641 };
 642
 643 class CAutoReferenceIterator : public CSmartLibgit2Ref<git_reference_iterator>
 644 {
 645 public:
 646         CAutoReferenceIterator() {};
 647
 648         ~CAutoReferenceIterator()
 649         {
 650                 CleanUp();
 651         }
 652
 653 private:
 654         CAutoReferenceIterator(const CAutoReferenceIterator&) = delete;
 655         CAutoReferenceIterator& operator=(const CAutoReferenceIterator&) = delete;
 656
 657 protected:
 658         virtual void FreeRef()
 659         {
 660                 git_reference_iterator_free(m_Ref);
 661         }
 662 };
 663
 664 class CAutoDescribeResult : public CSmartLibgit2Ref<git_describe_result>
 665 {
 666 public:
 667         CAutoDescribeResult() {};
 668
 669         ~CAutoDescribeResult()
 670         {
 671                 CleanUp();
 672         }
 673
 674 private:
 675         CAutoDescribeResult(const CAutoDescribeResult&) = delete;
 676         CAutoDescribeResult& operator=(const CAutoDescribeResult&) = delete;
 677
 678 protected:
 679         virtual void FreeRef()
 680         {
 681                 git_describe_result_free(m_Ref);
 682         }
 683 };
 684
 685 class CAutoStatusList : public CSmartLibgit2Ref<git_status_list>
 686 {
 687 public:
 688         CAutoStatusList() {};
 689
 690         ~CAutoStatusList()
 691         {
 692                 CleanUp();
 693         }
 694
 695 private:
 696         CAutoStatusList(const CAutoStatusList&) = delete;
 697         CAutoStatusList& operator=(const CAutoStatusList&) = delete;
 698
 699 protected:
 700         virtual void FreeRef()
 701         {
 702                 git_status_list_free(m_Ref);
 703         }
 704 };