src/Utils/SmartLibgit2Ref.h

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