src/Utils/SmartHandle.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2011 - TortoiseSVN
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 #pragma once
  20
  21
  22 /**
  23  * \ingroup Utils
  24  * Helper classes for handles.
  25  */
  26 template <typename HandleType,
  27         template <class> class CloseFunction,
  28         HandleType NULL_VALUE = NULL>
  29 class CSmartHandle : public CloseFunction<HandleType>
  30 {
  31 public:
  32         CSmartHandle()
  33         {
  34                 m_Handle = NULL_VALUE;
  35         }
  36
  37         CSmartHandle(HandleType h)
  38         {
  39                 m_Handle = h;
  40         }
  41
  42         HandleType operator=(HandleType h)
  43         {
  44                 if (m_Handle != h)
  45                 {
  46                         CleanUp();
  47                         m_Handle = h;
  48                 }
  49
  50                 return(*this);
  51         }
  52
  53         bool CloseHandle()
  54         {
  55                 return CleanUp();
  56         }
  57
  58         void Detach()
  59         {
  60                 m_Handle = NULL_VALUE;
  61         }
  62
  63         operator HandleType()
  64         {
  65                 return m_Handle;
  66         }
  67
  68         HandleType * GetPointer()
  69         {
  70                 return &m_Handle;
  71         }
  72
  73         operator bool()
  74         {
  75                 return IsValid();
  76         }
  77
  78         bool IsValid()
  79         {
  80                 return m_Handle != NULL_VALUE;
  81         }
  82
  83
  84         ~CSmartHandle()
  85         {
  86                 CleanUp();
  87         }
  88
  89
  90 protected:
  91         bool CleanUp()
  92         {
  93                 if ( m_Handle != NULL_VALUE )
  94                 {
  95                         bool b = Close(m_Handle);
  96                         m_Handle = NULL_VALUE;
  97                         return b;
  98                 }
  99                 return false;
 100         }
 101
 102
 103         HandleType m_Handle;
 104 };
 105
 106 class CEmptyClass
 107 {
 108 };
 109
 110 template <typename T>
 111 struct CCloseHandle
 112 {
 113         bool Close(T handle)
 114         {
 115                 return !!::CloseHandle(handle);
 116         }
 117
 118 protected:
 119         ~CCloseHandle()
 120         {
 121         }
 122 };
 123
 124
 125
 126 template <typename T>
 127 struct CCloseRegKey
 128 {
 129         bool Close(T handle)
 130         {
 131                 return RegCloseKey(handle) == ERROR_SUCCESS;
 132         }
 133
 134 protected:
 135         ~CCloseRegKey()
 136         {
 137         }
 138 };
 139
 140
 141 template <typename T>
 142 struct CCloseLibrary
 143 {
 144         bool Close(T handle)
 145         {
 146                 return !!::FreeLibrary(handle);
 147         }
 148
 149 protected:
 150         ~CCloseLibrary()
 151         {
 152         }
 153 };
 154
 155
 156 template <typename T>
 157 struct CCloseViewOfFile
 158 {
 159         bool Close(T handle)
 160         {
 161                 return !!::UnmapViewOfFile(handle);
 162         }
 163
 164 protected:
 165         ~CCloseViewOfFile()
 166         {
 167         }
 168 };
 169
 170 template <typename T>
 171 struct CCloseFindFile
 172 {
 173         bool Close(T handle)
 174         {
 175                 return !!::FindClose(handle);
 176         }
 177
 178 protected:
 179         ~CCloseFindFile()
 180         {
 181         }
 182 };
 183
 184
 185 // Client code (definitions of standard Windows handles).
 186 typedef CSmartHandle<HANDLE,    CCloseHandle>                                                                                   CAutoGeneralHandle;
 187 typedef CSmartHandle<HKEY,              CCloseRegKey>                                                                                   CAutoRegKey;
 188 typedef CSmartHandle<PVOID,             CCloseViewOfFile>                                                                               CAutoViewOfFile;
 189 typedef CSmartHandle<HMODULE,   CCloseLibrary>                                                                                  CAutoLibrary;
 190 typedef CSmartHandle<HANDLE,    CCloseHandle, INVALID_HANDLE_VALUE>                                             CAutoFile;
 191 typedef CSmartHandle<HANDLE,    CCloseFindFile, INVALID_HANDLE_VALUE>                                   CAutoFindFile;
 192
 193