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