|
|
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1996 - 1997.
//
// File: myhandle.hxx
//
// Contents: handle classes
//
// Classes: CAutoHandle, CFileHandle, CFindHandle, RegKeyHandle
// CAutoHandleTemplate<DWORD,BOOL (*)(HANDLE)>
//
// Functions:
//
// Coupling:
//
// Notes:
//
// History: 1-15-1997 ericne Created
//
//----------------------------------------------------------------------------
#ifndef _CMYHANDLE
#define _CMYHANDLE
#include <crtdbg.h>
#ifndef NEW
#define NEW new
#endif
#define NOT_NULL_OR_INVALID( h ) ( (h) && ~((UINT_PTR)(h)) )
//+---------------------------------------------------------------------------
//
// Class: autohandle_base
//
// Purpose: factor out code common to all handles
//
// Interface: operator== --
// operator!= --
// operator== --
// operator!= --
// operator== --
// operator!= --
// autohandle_base --
// ~autohandle_base --
// IsWrongHandle --
// m_handle --
//
// History: 5-13-1998 ericne Created
//
// Notes:
//
//----------------------------------------------------------------------------
class autohandle_base{ public: // Comparison operators
inline bool operator==( const autohandle_base & right ) const { #ifdef _DEBUG
if( IsWrongHandle( right.m_handle ) ) _RPT1( _CRT_ASSERT, "Bad handle comparison detected!" " this = %p", this ); #endif
return ( m_handle == right.m_handle ); } inline bool operator!=( const autohandle_base & right ) const { return ! operator==( right ); } // For comparisons with HANDLE types, including INVALID_HANDLE_VALUE
friend inline bool operator==( const HANDLE left, const autohandle_base & right ) { return right.operator==( left ); } friend inline bool operator!=( const HANDLE left, const autohandle_base & right ) { return ! right.operator==( left ); } inline bool operator==( const HANDLE right ) const { #ifdef _DEBUG
if( IsWrongHandle( right ) ) _RPT1( _CRT_ASSERT, "Bad handle comparison detected!" " this = %p", this ); #endif
return ( m_handle == right ); } inline bool operator!=( const HANDLE right ) const { return ! operator==( right ); } // These are for comparisons with NULL
friend inline bool operator==( const int left, const autohandle_base & right ) { return right.operator==( left ); } friend inline int operator!=( const int left, const autohandle_base & right ) { return ! right.operator==( left ); } inline bool operator==( const int right ) const { #ifdef _DEBUG
if( IsWrongHandle( (HANDLE)right ) ) _RPT1( _CRT_ASSERT, "Bad handle comparison detected!" " this = %p", this ); #endif
return ( m_handle == (HANDLE)right ); } inline bool operator!=( const int right ) const { return ! operator==( right ); }
protected: autohandle_base( HANDLE h ) : m_handle( h ) {} virtual ~autohandle_base() {} virtual bool IsWrongHandle( const HANDLE ) const = 0; HANDLE m_handle;};
//+---------------------------------------------------------------------------
//
// Class: basic_autohandle ()
//
// Purpose: To simplify the use of handles, and to prevent handle leaks
//
// Interface:
//
// History: 1-15-1997 ericne Created
//
// Notes: It is a template on UINT_PTR instead of HANDLE because you
// cannot template on a void pointer. The second template
// argument is the function to call in the destructor.
//
//----------------------------------------------------------------------------
template< UINT_PTR H, BOOL (*CLOSE)(HANDLE) >class basic_autohandle : public autohandle_base{ public:
basic_autohandle( const HANDLE ToCopy = (HANDLE)H ) : autohandle_base( ToCopy ), m_pulRefCount( NULL ) { if( NOT_NULL_OR_INVALID( m_handle ) ) m_pulRefCount = NEW LONG(1); #ifdef _DEBUG
if( IsWrongHandle( ToCopy ) ) _RPT1( _CRT_ASSERT, "Bad handle assignment detected!" " this = %p", this ); #endif
} basic_autohandle( const basic_autohandle<H,CLOSE>& ToCopy ) : autohandle_base( ToCopy.m_handle ), m_pulRefCount( ToCopy.m_pulRefCount ) { if( NOT_NULL_OR_INVALID( m_handle ) ) { _ASSERT( NULL != m_pulRefCount ); (void)AddRef(); }
#ifdef _DEBUG
if( IsWrongHandle( ToCopy.m_handle ) ) _RPT1( _CRT_ASSERT, "Bad handle assignment detected!" " this = %p", this ); #endif
} virtual ~basic_autohandle() { (void)Release(); }
basic_autohandle<H,CLOSE> & operator=( const basic_autohandle<H,CLOSE> & ToCopy ) { if( ( this != &ToCopy ) && ( m_handle != ToCopy.m_handle ) ) { this->basic_autohandle<H,CLOSE>::~basic_autohandle<H,CLOSE>(); this->basic_autohandle<H,CLOSE>::basic_autohandle<H,CLOSE>(ToCopy); } return *this; }
basic_autohandle<H,CLOSE> & operator=( const HANDLE ToCopy ) { if( m_handle != ToCopy ) { this->basic_autohandle<H,CLOSE>::~basic_autohandle<H,CLOSE>(); this->basic_autohandle<H,CLOSE>::basic_autohandle<H,CLOSE>(ToCopy); } return *this; } inline HANDLE GetHandle() { return m_handle; }
//
// These are for controlling the reference count on the handle
// These should not be needed usually, since the other members
// maintain the ref count. Use Release to Close a handle before
// the handle object goes out of scope
//
ULONG AddRef() { if( NULL == m_pulRefCount ) return 0; return InterlockedIncrement( m_pulRefCount ); }
ULONG Release() { if( NULL == m_pulRefCount ) return 0;
ULONG ulToReturn = InterlockedDecrement( m_pulRefCount );
if( 0 == ulToReturn ) { if( NOT_NULL_OR_INVALID( m_handle ) ) { if( ! CLOSE( m_handle ) ) _RPT1( _CRT_WARN, "Failed to close a handle. GetLast" "Error() returned 0x%08X", GetLastError() ); m_handle = (HANDLE)H; } delete m_pulRefCount; m_pulRefCount = NULL; }
return ulToReturn; }
protected: virtual bool IsWrongHandle( const HANDLE ToCopy ) const { return( ~H == (UINT_PTR)ToCopy ); }
LONG * m_pulRefCount;
};
//
// These are the most commonly used handles
//
// The AutoHandle has a default value of NULL ( 0 ) and calls CloseHandle
typedef basic_autohandle< (UINT_PTR) NULL, CloseHandle > CAutoHandle;
// The FileHandle has a default value of INVALID_HANDLE_VALUE ( -1 )
// and calls CloseHandle
typedef basic_autohandle< (UINT_PTR) INVALID_HANDLE_VALUE, CloseHandle > CFileHandle;
// The FindHandle has a default value of INVALID_HANDLE_VALUE ( -1 )
// and calls FindClose
typedef basic_autohandle< (UINT_PTR) INVALID_HANDLE_VALUE, FindClose > CFindHandle;
//+---------------------------------------------------------------------------
//
// Class: RegKeyHandle ()
//
// Purpose: Smart registry key handle which closes itself when it
// goes out of scope.
//
// Interface:
//
// History: 11-08-1996 ericne Created
//
// Notes:
//
//----------------------------------------------------------------------------
class RegKeyHandle{ public: RegKeyHandle() : m_hKey( NULL ) {} RegKeyHandle( const HKEY& hKey ) : m_hKey( hKey ) {}
~RegKeyHandle() { if( NOT_NULL_OR_INVALID( m_hKey ) ) { LONG lRetVal = RegCloseKey( m_hKey ); if( lRetVal != ERROR_SUCCESS ) _RPT1( _CRT_WARN, "RegCloseKey returned 0x%08X\r\n", lRetVal ); } m_hKey = NULL; }
RegKeyHandle & operator=( const RegKeyHandle & hKey ) { if( ( this != &hKey ) && ( m_hKey != hKey.m_hKey ) ) { this->RegKeyHandle::~RegKeyHandle(); this->RegKeyHandle::RegKeyHandle( hKey ); } return *this; }
RegKeyHandle & operator=( const HKEY & hKey ) { if( m_hKey != hKey ) { this->RegKeyHandle::~RegKeyHandle(); this->RegKeyHandle::RegKeyHandle( hKey ); } return *this; }
operator HKEY() { return m_hKey; }
operator PHKEY() { return &m_hKey; }
bool operator==( const int right ) { return (int)( (void *const)right == m_hKey ); }
bool operator!=( const int right ) { return (int)( (void *const)right != m_hKey ); }
friend bool operator==( const int left, const RegKeyHandle & right ) { return( (void *const)left == right.m_hKey ); }
friend bool operator!=( const int left, const RegKeyHandle & right ) { return( (void *const)left != right.m_hKey ); }
private:
HKEY m_hKey;};
#endif
|
