Cleaned up CA exceptions. Integrated free-standing handle class.

installer/src/installer-lib/handle.h

 /**
  * \file handle.h The "install session" is the context for all custom installation behavior.
  */
 
 #ifndef HANDLE_H
 #define HANDLE_H
 
 #include "windows.h"
 #include "msi.h"
 
@@ skipping 51 matching lines @@
  * Policy class that indicates that a raw handle is permitted to be zero.
  */
 template< class T >
 struct Allow_Null
 {
   inline static bool prohibited_always() { return false ; }
   inline static bool prohibited_from_outside() { return false ; }
 } ;
 
 /**
- * Policy class that does not close a file handle when it goes out of scope
+ * Policy class that does not close a handle at all.
  */
 template< class T >
 class No_Destruction
 {
 public:
   inline static void close( T handle ) {} ;
 } ;
 
 /**
- * Policy class that does not close a file handle when it goes out of scope
+ * Policy class that closes an MSI handle when it goes out of scope.
  */
 template< class T >
 class MSI_Generic_Destruction
 {
 public:
   inline static void close( T handle )
   {
     MsiCloseHandle( handle ) ;
   } ;
 } ;
 
+/**
+ * Policy class that closes a Windows handle when it goes out of scope.
+ */
+template< class T >
+class Windows_Generic_Destruction
+{
+public:
+  inline static void close( T handle )
+  {
+    CloseHandle( handle ) ;
+  } ;
+} ;
+
 
 //-------------------------------------------------------
 // Handle
 //-------------------------------------------------------
 /**
  * Raw handle is the base class for the generic handle.
  *
  * Raw handles always allow null, so that generic handles may allow or disallow them as they please.
  */
 template< class T >
@@ skipping 37 matching lines @@
  * Handle class
  */
 template<
   class T,
   template <class> class Null_Policy,
   template <class> class Destruction_Policy = No_Destruction
 >
 class handle
   : public handle_raw< T >
 {
+  /**
+   * Copy constructor prohibited.
+   *
+   * This class represents an external resource and is responsible for its lifecycle.
+   * As such, the semantics here require a one-to-one match between instances and resource.
+   * Copy construction violates these semantics.
+   *
+   * \par Implementation
+   *   Currently, declared private and not defined.
+   *   Add "= delete" for C++11.
+   */
+  handle( handle & ) ;
+
+  /**
+   * Copy assignment not implemented.
+   *
+   * It's not used anywhere yet.
+   *
+   * \par Implementation
+   *   Currently, declared private and not defined.
+   */
+  handle operator=( const handle & ) ;
+
+  /**
+   * Validate initial handle values, both for construction and reinitialization assignment.
+   */
+  T validate_handle( T handle )
+  {
+    if ( Null_Policy< T >::prohibited_from_outside() && handle == 0 )
+    {
+      throw null_handle_error() ;
+    }
+    return handle ;
+  }
+
 protected:
   /**
    * Tag class for null record constructor
    */
   class null_t {} ;
 
   /**
    * Null handle constructor initializes its handle to zero.
    *
    * The null record constructor avoids the ordinary check that an external handle not be zero.
    * It's declared protected so that it's not ordinarily visible.
    * To use this constructor, derive from it and add a friend declaration.
    */
   handle( null_t )
     : handle_raw( 0 )
   {
     if ( Null_Policy< T >::prohibited_always() )
     {
       throw null_handle_error() ;
     }
   }
 
 public:
   /**
    * Ordinary constructor.
    *
    * A check for a non-zero handle compiles in conditionally based on the Null_Policy.
    */
-  handle( T _handle )
-    : handle_raw( _handle )
+  handle( T handle )
+    : handle_raw( validate_handle( handle ) )
+  {}
+
+  /**
+   * Reinitialization Assignment.
+   *
+   * If we had C++11 move constructors, we wouldn't need this, since this acts exactly as construct-plus-move would.
+   */
+  handle & operator=( T handle )
   {
-    if ( Null_Policy< T >::prohibited_from_outside() && _handle == 0 )
-    {
-      throw null_handle_error() ;
-    }
+    validate_handle( handle ) ;
+    this -> ~handle() ;
+    _handle = handle ;
+    return * this ;
   }
 
   /**
    * Destructor
    *
    * The check for a non-zero handle compiles out conditionally based on Null_Policy.
    * The specific function used to close the handle is given by the Destruction_Policy.
    */
   ~handle()
   {
     if ( Null_Policy< T >::prohibited_always() || ( _handle != 0 ) ) {
       Destruction_Policy< T >::close( _handle ) ;
     }
   }
 
 } ;
 
+//-------------------------------------------------------
+// Common instantiations of handle
+//-------------------------------------------------------
+typedef handle< HANDLE, Disallow_Null, Windows_Generic_Destruction > Windows_Handle ;
+
 #endif