mi32/registry.h

Go to the documentation of this file.

/****
 * \file mi32\registry.h
 * \brief Class REGISTRY - Handle registry API's through this class
 * \if NODOC
 * $Id: registry.h_v 1.13 2007/05/25 21:30:53 scowan Exp $
 *
 * $Log: registry.h_v $
 * Revision 1.13  2007/05/25 21:30:53  scowan
 * Added grantWriteAccessTo method.
 *
 * Revision 1.12  2007/05/17 19:41:06  scowan
 * Added date time class storage methods.
 *
 * Revision 1.11  2006/12/08 18:51:39  scowan
 * Added patchTo method.
 *
 * Revision 1.10  2006/11/22 17:55:02  scowan
 * Added bitset unowned variants for get and set values.
 *
 * Revision 1.9  2006/10/09 15:08:21  scowan
 * Forward declare filepath, filepathlist, mistring, mistringlist.
 *
 * Revision 1.8  2006/10/04 14:58:49  scowan
 * Added simple array uint8 version of get and set values.
 *
 * Revision 1.7  2006/04/13 19:15:57  scowan
 * *** empty log message ***
 *
 * Revision 1.6  2006/04/12 20:29:16  scowan
 * Attempt to fix doxygen docs.
 *
 * Revision 1.5  2006/03/20 17:24:26  scowan
 * Fixed doxygen issues.
 *
 * Revision 1.4  2005/05/18 17:33:48  scowan
 * Aded save and restore methods.
 *
 * Revision 1.3  2005/01/21 22:07:08  scowan
 * Added flag.
 *
 * Revision 1.2  2005/01/11 00:30:57  scowan
 * Added methods.
 *
 * Revision 1.1  2004/12/27 22:38:04  scowan
 * Initial revision
 *
 * \endif
****/

#ifndef  INC_MI32_REGISTRY_H
#define  INC_MI32_REGISTRY_H

#if defined(WIN32)
#ifndef GENERATING_DOXYGEN_OUTPUT
#include <windows.h>
#endif   // GENERATING_DOXYGEN_OUTPUT

#ifndef INC_MI32_STDDEFNS_H
   #include <mi32/stddefns.h>
#endif

#ifndef INC_MI32_SIMPLEAR_H
   #include <mi32/simplear.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations
class BITSET_UNOWNED;
class DATETIME;
class FILEPATH;
class FILEPATHLIST;
class MISTRING;
class MISTRINGLIST;
#endif   // GENERATING_DOXYGEN_OUTPUT

#ifdef MISYSTEMDLL
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif


class CLASSLIBEXPORT REGISTRY {
   public:

      enum ACCESS {
         ACCESS_Read,
         ACCESS_Write,
         ACCESS_Notify,
         ACCESS_All
         };

      enum BASE {
         BASE_ClassesRoot,
         BASE_CurrentUser,
         BASE_LocalMachine,
         BASE_Users
         };

      REGISTRY (
         );

      REGISTRY (
         const REGISTRY& rhs
         );

      ~REGISTRY (
         );

      REGISTRY& operator= (
         const REGISTRY& rhs
         );

      void Close (
         );

      ERRVALUE CreateKey (
         const char* name,
         REGISTRY& DestKey             
         );

      ERRVALUE CreateKey (
         const MISTRING& name,
         REGISTRY& DestKey             
         );

      void DeleteSubKey (
         const char* name
         );

      void DeleteSubKey (
         const MISTRING& name
         );

      void DeleteAllSubKeys (
         );

      void GetKeyNames (
         MISTRINGLIST& KeyList
         ) const;

      void GetValue (
         const char* name,
         bool& value,
         const bool dft = false
         ) const;

      void GetValue (
         const MISTRING& name,
         bool& value,
         const bool dft = false
         ) const;

      void GetValue (
         const char* name,
         BITSET_UNOWNED& value,
         const bool dft = false
         ) const;

      void GetValue (
         const MISTRING& name,
         BITSET_UNOWNED& value,
         const bool dft = false
         ) const;

      void GetValue (
         const char* name,
         UINT64& value,
         const UINT64 dft,
         const UINT64 min,
         const UINT64 max
         ) const;

      void GetValue (
         const MISTRING& name,
         UINT64& value,
         const UINT64 dft,
         const UINT64 min,
         const UINT64 max
         ) const;

      void GetValue (
         const char* name,
         UINT32& value,
         const UINT32 dft = 0,
         const UINT32 min = 0,
         const UINT32 max = 0
         ) const;

      void GetValue (
         const MISTRING& name,
         UINT32& value,
         const UINT32 dft = 0,
         const UINT32 min = 0,
         const UINT32 max = 0
         ) const;

      void GetValue (
         const char* name,
         INT32& value,
         const INT32 dft = 0,
         const INT32 min = 0,
         const INT32 max = 0
         ) const;

      void GetValue (
         const MISTRING& name,
         INT32& value,
         const INT32 dft = 0,
         const INT32 min = 0,
         const INT32 max = 0
         ) const;

      void GetValue (
         const char* name,
         MISTRING& newstring
         ) const;

      void GetValue (
         const MISTRING& name,
         MISTRING& newstring
         ) const;

      void GetValue (
         const char* name,
         MISTRINGLIST& StrList
         ) const;

      void GetValue (
         const MISTRING& name,
         MISTRINGLIST& StrList
         ) const;

      void GetValue (
         const char* name,
         FILEPATH& filepath
         ) const;

      void GetValue (
         const MISTRING& name,
         FILEPATH& filepath
         ) const;

      void GetValue (
         const char* name,
         FILEPATHLIST& PathList
         ) const;

      void GetValue (
         const MISTRING& name,
         FILEPATHLIST& PathList
         ) const;

      void GetValue (
         const char* name,
         SIMPLE_ARRAY<UINT8>& binary
         ) const;

      void GetValue (
         const MISTRING& name,
         SIMPLE_ARRAY<UINT8>& binary
         ) const;

      void GetValue (
         const char* name,
         DATETIME& dt
         ) const;

      void GetValue (
         const MISTRING& name,
         DATETIME& dt
         ) const;

      void GetValueNames (
         MISTRINGLIST& NameList
         ) const;

      bool GrantWriteAccessTo (
         const MISTRING& AccountName         
         );

      bool IsOpen (
         ) const;

      bool KeyExists (
         const char* KeyName
         ) const;

      bool KeyExists (
         const MISTRING& KeyName
         ) const;

      ERRVALUE OpenKey (
         const char* name,
         ACCESS Access = ACCESS_Read
         );

      ERRVALUE OpenKey (
         const MISTRING& name,
         ACCESS Access = ACCESS_Read
         );

      ERRVALUE OpenKey (
         BASE root,
         const char* name,
         ACCESS Access = ACCESS_Read
         );

      ERRVALUE OpenKey (
         BASE root,
         const MISTRING& name,
         ACCESS Access = ACCESS_Read
         );

      ERRVALUE OpenKey (
         const REGISTRY& parent,
         const char* name,
         ACCESS Access = ACCESS_Read
         );

      ERRVALUE OpenKey (
         const REGISTRY& parent,
         const MISTRING& name,
         ACCESS Access = ACCESS_Read
         );

      ERRVALUE OpenRemoteKey (
         BASE root,
         const MISTRING& MachineName
         );

      ERRVALUE PatchTo (
         REGISTRY& DestKey
         );

      ERRVALUE Restore (
         const FILEPATH& filename
         );

      ERRVALUE Save (
         const FILEPATH& filename
         ) const;

      ERRVALUE SetChangeNotifyEvent (
         HANDLE Event
         );

      ERRVALUE SetValue (
         const char* name,
         const BITSET_UNOWNED& value
         );
      
      ERRVALUE SetValue (
         const MISTRING& name,
         const BITSET_UNOWNED& value
         );
      
      ERRVALUE SetValue (
         const char* name,
         const MISTRING& value
         );
      
      ERRVALUE SetValue (
         const MISTRING& name,
         const MISTRING& value
         );
      
      ERRVALUE SetValue (
         const char* name,
         INT32 value
         );

      ERRVALUE SetValue (
         const MISTRING& name,
         INT32 value
         );

      ERRVALUE SetValue64 (
         const char* name,
         INT64 value
         );

      ERRVALUE SetValue64 (         
         const MISTRING& name,
         INT64 value
         );

      ERRVALUE SetValue (
         const char* name,
         const MISTRINGLIST& StrList
         );

      ERRVALUE SetValue (
         const MISTRING& name,
         const MISTRINGLIST& StrList
         );

      ERRVALUE SetValue (
         const char* name,
         const FILEPATHLIST& PathList
         );

      ERRVALUE SetValue (
         const MISTRING& name,
         const FILEPATHLIST& PathList
         );

      ERRVALUE SetValue (
         const char* name,
         const SIMPLE_ARRAY<UINT8>& binary
         );

      ERRVALUE SetValue (
         const MISTRING& name,
         const SIMPLE_ARRAY<UINT8>& binary
         );

      ERRVALUE SetValue (
         const char* name,
         const DATETIME& dt
         );

      ERRVALUE SetValue (
         const MISTRING& name,
         const DATETIME& dt
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      HKEY m_hk;
      #endif   // GENERATING_DOXYGEN_OUTPUT
   };


#undef   CLASSLIBEXPORT
#endif   // if defined(WIN32)
#endif   // INC_MI32_REGISTRY_H 

---