src/Utils/SmartHandle.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2011, 2015 - TortoiseSVN
   4 // Copyright (C) 2015 - TortoiseGit
   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
  22
  23 /**
  24  * \ingroup Utils
  25  * Helper classes for handles.
  26  */
  27 template <typename HandleType,
  28         template <class> class CloseFunction,
  29         HandleType NULL_VALUE = nullptr>
  30 class CSmartHandle
  31 {
  32 public:
  33         CSmartHandle()
  34         {
  35                 m_Handle = NULL_VALUE;
  36         }
  37
  38         CSmartHandle(HandleType h)
  39         {
  40                 m_Handle = h;
  41         }
  42
  43         HandleType operator=(HandleType h)
  44         {
  45                 if (m_Handle != h)
  46                 {
  47                         CleanUp();
  48                         m_Handle = h;
  49                 }
  50
  51                 return(*this);
  52         }
  53
  54         bool CloseHandle()
  55         {
  56                 return CleanUp();
  57         }
  58
  59         HandleType Detach()
  60         {
  61                 HandleType p = m_Handle;
  62                 m_Handle = NULL_VALUE;
  63
  64                 return p;
  65         }
  66
  67         operator HandleType() const
  68         {
  69                 return m_Handle;
  70         }
  71
  72         HandleType * GetPointer()
  73         {
  74                 return &m_Handle;
  75         }
  76
  77         operator bool() const
  78         {
  79                 return IsValid();
  80         }
  81
  82         bool IsValid() const
  83         {
  84                 return m_Handle != NULL_VALUE;
  85         }
  86
  87
  88         ~CSmartHandle()
  89         {
  90                 CleanUp();
  91         }
  92
  93 private:
  94         CSmartHandle(const CSmartHandle&) = delete;
  95         CSmartHandle& operator=(const CSmartHandle&) = delete;
  96
  97 protected:
  98         bool CleanUp()
  99         {
 100                 if ( m_Handle != NULL_VALUE )
 101                 {
 102                         const bool b = CloseFunction<HandleType>::Close(m_Handle);
 103                         m_Handle = NULL_VALUE;
 104                         return b;
 105                 }
 106                 return false;
 107         }
 108
 109
 110         HandleType m_Handle;
 111 };
 112
 113 template <typename T>
 114 struct CCloseHandle
 115 {
 116         static bool Close(T handle)
 117         {
 118                 return !!::CloseHandle(handle);
 119         }
 120 };
 121
 122
 123
 124 template <typename T>
 125 struct CCloseRegKey
 126 {
 127         static bool Close(T handle)
 128         {
 129                 return RegCloseKey(handle) == ERROR_SUCCESS;
 130         }
 131 };
 132
 133
 134 template <typename T>
 135 struct CCloseLibrary
 136 {
 137         static bool Close(T handle)
 138         {
 139                 return !!::FreeLibrary(handle);
 140         }
 141 };
 142
 143
 144 template <typename T>
 145 struct CCloseViewOfFile
 146 {
 147         static bool Close(T handle)
 148         {
 149                 return !!::UnmapViewOfFile(handle);
 150         }
 151 };
 152
 153 template <typename T>
 154 struct CCloseFindFile
 155 {
 156         static bool Close(T handle)
 157         {
 158                 return !!::FindClose(handle);
 159         }
 160 };
 161
 162 template <typename T>
 163 struct CCloseFILE
 164 {
 165         static bool Close(T handle)
 166         {
 167                 return !!fclose(handle);
 168         }
 169 };
 170
 171
 172 // Client code (definitions of standard Windows handles).
 173 typedef CSmartHandle<HANDLE,    CCloseHandle>                                                                                   CAutoGeneralHandle;
 174 typedef CSmartHandle<HKEY,              CCloseRegKey>                                                                                   CAutoRegKey;
 175 typedef CSmartHandle<PVOID,             CCloseViewOfFile>                                                                               CAutoViewOfFile;
 176 typedef CSmartHandle<HMODULE,   CCloseLibrary>                                                                                  CAutoLibrary;
 177 typedef CSmartHandle<HANDLE,    CCloseHandle, INVALID_HANDLE_VALUE>                                             CAutoFile;
 178 typedef CSmartHandle<HANDLE,    CCloseFindFile, INVALID_HANDLE_VALUE>                                   CAutoFindFile;
 179 typedef CSmartHandle<FILE*,             CCloseFILE>                                                                                             CAutoFILE;