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-2016, 2019-2020 - 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 #include <Uxtheme.h>
  22
  23 template <typename type>
  24 struct CDefaultHandleNull
  25 {
  26         static constexpr type DefaultHandle()
  27         {
  28                 return nullptr;
  29         }
  30 };
  31
  32 struct CDefaultHandleInvalid
  33 {
  34         static constexpr HANDLE DefaultHandle()
  35         {
  36                 return INVALID_HANDLE_VALUE;
  37         }
  38 };
  39
  40 /**
  41  * \ingroup Utils
  42  * Helper classes for handles.
  43  */
  44 template <typename HandleType,
  45         template <class> class CloseFunction,
  46         typename NullType = CDefaultHandleNull<HandleType>>
  47 class CSmartHandle
  48 {
  49 public:
  50         CSmartHandle()
  51                 : m_Handle(NullType::DefaultHandle())
  52         {
  53         }
  54
  55         CSmartHandle(HandleType&& h)
  56                 : m_Handle(h)
  57         {
  58         }
  59
  60         CSmartHandle(CSmartHandle&& h)
  61                 : m_Handle(h.Detach())
  62         {
  63         }
  64
  65         CSmartHandle& operator=(CSmartHandle&& h)
  66         {
  67                 *this = h.Detach();
  68                 return *this;
  69         }
  70
  71         HandleType& operator=(HandleType&& h)
  72         {
  73                 if (m_Handle != h)
  74                 {
  75                         CleanUp();
  76                         m_Handle = h;
  77                 }
  78
  79                 return m_Handle;
  80         }
  81
  82         bool CloseHandle()
  83         {
  84                 return CleanUp();
  85         }
  86
  87         HandleType Detach()
  88         {
  89                 HandleType p = m_Handle;
  90                 m_Handle = NullType::DefaultHandle();
  91
  92                 return p;
  93         }
  94
  95         operator HandleType() const
  96         {
  97                 return m_Handle;
  98         }
  99
 100         HandleType * GetPointer()
 101         {
 102                 return &m_Handle;
 103         }
 104
 105         operator bool() const
 106         {
 107                 return IsValid();
 108         }
 109
 110         bool IsValid() const
 111         {
 112                 return m_Handle != NullType::DefaultHandle();
 113         }
 114
 115
 116         ~CSmartHandle()
 117         {
 118                 CleanUp();
 119         }
 120
 121 private:
 122         CSmartHandle(const HandleType&) = delete;
 123         CSmartHandle(const CSmartHandle&) = delete;
 124         HandleType& operator=(const HandleType&) = delete;
 125         CSmartHandle& operator=(const CSmartHandle&) = delete;
 126
 127 protected:
 128         bool CleanUp()
 129         {
 130                 if (m_Handle != NullType::DefaultHandle())
 131                 {
 132                         const bool b = CloseFunction<HandleType>::Close(m_Handle);
 133                         m_Handle = NullType::DefaultHandle();
 134                         return b;
 135                 }
 136                 return false;
 137         }
 138
 139
 140         HandleType m_Handle;
 141 };
 142
 143 template <typename T>
 144 struct CCloseHandle
 145 {
 146         static bool Close(T handle)
 147         {
 148                 return !!::CloseHandle(handle);
 149         }
 150 };
 151
 152
 153
 154 template <typename T>
 155 struct CCloseRegKey
 156 {
 157         static bool Close(T handle)
 158         {
 159                 return RegCloseKey(handle) == ERROR_SUCCESS;
 160         }
 161 };
 162
 163
 164 template <typename T>
 165 struct CCloseLibrary
 166 {
 167         static bool Close(T handle)
 168         {
 169                 return !!::FreeLibrary(handle);
 170         }
 171 };
 172
 173
 174 template <typename T>
 175 struct CCloseViewOfFile
 176 {
 177         static bool Close(T handle)
 178         {
 179                 return !!::UnmapViewOfFile(handle);
 180         }
 181 };
 182
 183 template <typename T>
 184 struct CCloseFindFile
 185 {
 186         static bool Close(T handle)
 187         {
 188                 return !!::FindClose(handle);
 189         }
 190 };
 191
 192 template <typename T>
 193 struct CCloseFILE
 194 {
 195         static bool Close(T handle)
 196         {
 197                 return !!fclose(handle);
 198         }
 199 };
 200
 201 template <typename T>
 202 struct CCloseThemeData
 203 {
 204         static bool Close(T hTheme)
 205         {
 206                 return !!::CloseThemeData(hTheme);
 207         }
 208 };
 209
 210 template <typename T>
 211 struct CCloseIcon
 212 {
 213         static bool Close(T handle)
 214         {
 215                 return !!DestroyIcon(handle);
 216         }
 217 };
 218
 219 // Client code (definitions of standard Windows handles).
 220 typedef CSmartHandle<HANDLE,    CCloseHandle>                                                                                   CAutoGeneralHandle;
 221 typedef CSmartHandle<HKEY,              CCloseRegKey>                                                                                   CAutoRegKey;
 222 typedef CSmartHandle<PVOID,             CCloseViewOfFile>                                                                               CAutoViewOfFile;
 223 typedef CSmartHandle<HMODULE,   CCloseLibrary>                                                                                  CAutoLibrary;
 224 typedef CSmartHandle<HANDLE,    CCloseHandle, CDefaultHandleInvalid>                                    CAutoFile;
 225 typedef CSmartHandle<HANDLE,    CCloseFindFile, CDefaultHandleInvalid>                                  CAutoFindFile;
 226 typedef CSmartHandle<FILE*,             CCloseFILE>                                                                                             CAutoFILE;
 227 typedef CSmartHandle<HTHEME,    CCloseThemeData>                                                                                CAutoThemeData;
 228 typedef CSmartHandle<HICON,             CCloseIcon>                                                                                             CAutoIcon;
 229
 230 /*
 231 void CompilerTests()
 232 {
 233         // compiler tests
 234         {
 235                 HANDLE h = reinterpret_cast<HANDLE>(1);
 236                 CAutoFile hFile = h;                    // C2280
 237                 CAutoFile hFile2 = std::move(h);        // OK
 238                 // OK, uses move semantics
 239                 CAutoFile hFile3 = CreateFile(L"c:\\test.txt", GENERIC_WRITE, FILE_SHARE_READ, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
 240                 CAutoFile hFile4 = hFile3;              // C2280
 241                 CAutoFile hFile5 = std::move(hFile3);   // OK
 242         }
 243 }
 244 */