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