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