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
  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 CAutoTreeEntry : public CSmartLibgit2Ref<git_tree_entry>
 429 {
 430 public:
 431         CAutoTreeEntry() {};
 432
 433         ~CAutoTreeEntry()
 434         {
 435                 CleanUp();
 436         }
 437
 438 private:
 439         CAutoTreeEntry(const CAutoTreeEntry&) = delete;
 440         CAutoTreeEntry& operator=(const CAutoTreeEntry&) = delete;
 441
 442 protected:
 443         virtual void FreeRef()
 444         {
 445                 git_tree_entry_free(m_Ref);
 446         }
 447 };
 448
 449 class CAutoDiff : public CSmartLibgit2Ref<git_diff>
 450 {
 451 public:
 452         CAutoDiff() {};
 453
 454         ~CAutoDiff()
 455         {
 456                 CleanUp();
 457         }
 458
 459 private:
 460         CAutoDiff(const CAutoDiff&) = delete;
 461         CAutoDiff& operator=(const CAutoDiff&) = delete;
 462
 463 protected:
 464         virtual void FreeRef()
 465         {
 466                 git_diff_free(m_Ref);
 467         }
 468 };
 469
 470 class CAutoPatch : public CSmartLibgit2Ref<git_patch>
 471 {
 472 public:
 473         CAutoPatch() {};
 474
 475         ~CAutoPatch()
 476         {
 477                 CleanUp();
 478         }
 479
 480 private:
 481         CAutoPatch(const CAutoPatch&) = delete;
 482         CAutoPatch& operator=(const CAutoPatch&) = delete;
 483
 484 protected:
 485         virtual void FreeRef()
 486         {
 487                 git_patch_free(m_Ref);
 488         }
 489 };
 490
 491 class CAutoDiffStats : public CSmartLibgit2Ref<git_diff_stats>
 492 {
 493 public:
 494         CAutoDiffStats() {};
 495
 496         ~CAutoDiffStats()
 497         {
 498                 CleanUp();
 499         }
 500
 501 private:
 502         CAutoDiffStats(const CAutoDiffStats&) = delete;
 503         CAutoDiffStats& operator=(const CAutoDiffStats&) = delete;
 504
 505 protected:
 506         virtual void FreeRef()
 507         {
 508                 git_diff_stats_free(m_Ref);
 509         }
 510 };
 511
 512 class CAutoIndex : public CSmartLibgit2Ref<git_index>
 513 {
 514 public:
 515         CAutoIndex() {};
 516
 517         ~CAutoIndex()
 518         {
 519                 CleanUp();
 520         }
 521
 522 private:
 523         CAutoIndex(const CAutoIndex& that);
 524         CAutoIndex& operator=(const CAutoIndex& that);
 525
 526 protected:
 527         virtual void FreeRef()
 528         {
 529                 git_index_free(m_Ref);
 530         }
 531 };
 532
 533 class CAutoRemote : public CSmartLibgit2Ref<git_remote>
 534 {
 535 public:
 536         CAutoRemote() {};
 537
 538         ~CAutoRemote()
 539         {
 540                 CleanUp();
 541         }
 542
 543 private:
 544         CAutoRemote(const CAutoRemote&) = delete;
 545         CAutoRemote& operator=(const CAutoRemote&) = delete;
 546
 547 protected:
 548         virtual void FreeRef()
 549         {
 550                 git_remote_free(m_Ref);
 551         }
 552 };
 553
 554 class CAutoReflog : public CSmartLibgit2Ref<git_reflog>
 555 {
 556 public:
 557         CAutoReflog() {};
 558
 559         ~CAutoReflog()
 560         {
 561                 CleanUp();
 562         }
 563
 564 private:
 565         CAutoReflog(const CAutoReflog&) = delete;
 566         CAutoReflog& operator=(const CAutoReflog&) = delete;
 567
 568 protected:
 569         virtual void FreeRef()
 570         {
 571                 git_reflog_free(m_Ref);
 572         }
 573 };
 574
 575 class CAutoRevwalk : public CSmartLibgit2Ref<git_revwalk>
 576 {
 577 public:
 578         CAutoRevwalk() {};
 579
 580         ~CAutoRevwalk()
 581         {
 582                 CleanUp();
 583         }
 584
 585 private:
 586         CAutoRevwalk(const CAutoRevwalk&) = delete;
 587         CAutoRevwalk& operator=(const CAutoRevwalk&) = delete;
 588
 589 protected:
 590         virtual void FreeRef()
 591         {
 592                 git_revwalk_free(m_Ref);
 593         }
 594 };
 595
 596 class CAutoBranchIterator : public CSmartLibgit2Ref<git_branch_iterator>
 597 {
 598 public:
 599         CAutoBranchIterator() {};
 600
 601         ~CAutoBranchIterator()
 602         {
 603                 CleanUp();
 604         }
 605
 606 private:
 607         CAutoBranchIterator(const CAutoBranchIterator&) = delete;
 608         CAutoBranchIterator& operator=(const CAutoBranchIterator&) = delete;
 609
 610 protected:
 611         virtual void FreeRef()
 612         {
 613                 git_branch_iterator_free(m_Ref);
 614         }
 615 };
 616
 617 class CAutoDescribeResult : public CSmartLibgit2Ref<git_describe_result>
 618 {
 619 public:
 620         CAutoDescribeResult() {};
 621
 622         ~CAutoDescribeResult()
 623         {
 624                 CleanUp();
 625         }
 626
 627 private:
 628         CAutoDescribeResult(const CAutoDescribeResult&) = delete;
 629         CAutoDescribeResult& operator=(const CAutoDescribeResult&) = delete;
 630
 631 protected:
 632         virtual void FreeRef()
 633         {
 634                 git_describe_result_free(m_Ref);
 635         }
 636 };
 637
 638 class CAutoStatusList : public CSmartLibgit2Ref<git_status_list>
 639 {
 640 public:
 641         CAutoStatusList() {};
 642
 643         ~CAutoStatusList()
 644         {
 645                 CleanUp();
 646         }
 647
 648 private:
 649         CAutoStatusList(const CAutoStatusList&) = delete;
 650         CAutoStatusList& operator=(const CAutoStatusList&) = delete;
 651
 652 protected:
 653         virtual void FreeRef()
 654         {
 655                 git_status_list_free(m_Ref);
 656         }
 657 };