src/Utils/SmartHandle.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2011 - 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 = NULL>
  30 class CSmartHandle : public CloseFunction<HandleType>
  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;
  62
  63                 p = m_Handle;
  64                 m_Handle = NULL_VALUE;
  65
  66                 return p;
  67         }
  68
  69         operator HandleType()
  70         {
  71                 return m_Handle;
  72         }
  73
  74         HandleType * GetPointer()
  75         {
  76                 return &m_Handle;
  77         }
  78
  79         operator bool()
  80         {
  81                 return IsValid();
  82         }
  83
  84         bool IsValid()
  85         {
  86                 return m_Handle != NULL_VALUE;
  87         }
  88
  89
  90         ~CSmartHandle()
  91         {
  92                 CleanUp();
  93         }
  94
  95 private:
  96         CSmartHandle(const CSmartHandle& that);
  97         CSmartHandle& operator=(const CSmartHandle& that);
  98
  99 protected:
 100         bool CleanUp()
 101         {
 102                 if ( m_Handle != NULL_VALUE )
 103                 {
 104                         bool b = Close(m_Handle);
 105                         m_Handle = NULL_VALUE;
 106                         return b;
 107                 }
 108                 return false;
 109         }
 110
 111
 112         HandleType m_Handle;
 113 };
 114
 115 class CEmptyClass
 116 {
 117 };
 118
 119 template <typename T>
 120 struct CCloseHandle
 121 {
 122         bool Close(T handle)
 123         {
 124                 return !!::CloseHandle(handle);
 125         }
 126
 127 protected:
 128         ~CCloseHandle()
 129         {
 130         }
 131 };
 132
 133
 134
 135 template <typename T>
 136 struct CCloseRegKey
 137 {
 138         bool Close(T handle)
 139         {
 140                 return RegCloseKey(handle) == ERROR_SUCCESS;
 141         }
 142
 143 protected:
 144         ~CCloseRegKey()
 145         {
 146         }
 147 };
 148
 149
 150 template <typename T>
 151 struct CCloseLibrary
 152 {
 153         bool Close(T handle)
 154         {
 155                 return !!::FreeLibrary(handle);
 156         }
 157
 158 protected:
 159         ~CCloseLibrary()
 160         {
 161         }
 162 };
 163
 164
 165 template <typename T>
 166 struct CCloseViewOfFile
 167 {
 168         bool Close(T handle)
 169         {
 170                 return !!::UnmapViewOfFile(handle);
 171         }
 172
 173 protected:
 174         ~CCloseViewOfFile()
 175         {
 176         }
 177 };
 178
 179 template <typename T>
 180 struct CCloseFindFile
 181 {
 182         bool Close(T handle)
 183         {
 184                 return !!::FindClose(handle);
 185         }
 186
 187 protected:
 188         ~CCloseFindFile()
 189         {
 190         }
 191 };
 192
 193
 194 // Client code (definitions of standard Windows handles).
 195 typedef CSmartHandle<HANDLE,    CCloseHandle>                                                                                   CAutoGeneralHandle;
 196 typedef CSmartHandle<HKEY,              CCloseRegKey>                                                                                   CAutoRegKey;
 197 typedef CSmartHandle<PVOID,             CCloseViewOfFile>                                                                               CAutoViewOfFile;
 198 typedef CSmartHandle<HMODULE,   CCloseLibrary>                                                                                  CAutoLibrary;
 199 typedef CSmartHandle<HANDLE,    CCloseHandle, INVALID_HANDLE_VALUE>                                             CAutoFile;
 200 typedef CSmartHandle<HANDLE,    CCloseFindFile, INVALID_HANDLE_VALUE>                                   CAutoFindFile;
 201
 202