regsettings.h

ftpserver very good sample

/******************************************************************************
Module name: RegSettings.cpp
Written by:  Jeffrey Richter
Purpose:     CRegSettings C++ class to help with registry manipulations
******************************************************************************/


#pragma once


/////////////////////////////////////////////////////////////////////////////


class CRegSettings {
public:  // Constructors/destructor
   CRegSettings() : m_hkeySubkey(NULL) { };

   CRegSettings(BOOL fReadOnly, HKEY hkeyRoot, LPCWSTR pszSubkey)
      : m_hkeySubkey(NULL) {
      OpenSubkey(fReadOnly, hkeyRoot, pszSubkey);
   }

   ~CRegSettings() { CloseKey(); }


public:  // Opening/closing registry subkey functions
   operator HKEY() const { return(m_hkeySubkey); }

   LONG OpenSubkey(BOOL fReadOnly, HKEY hkeyRoot, LPCWSTR pszSubkey) {
      CloseKey();
      LONG lErr;
      if (fReadOnly) {
         lErr = ::RegOpenKeyExW(hkeyRoot, pszSubkey, 0, 
            KEY_QUERY_VALUE, &m_hkeySubkey); 
      } else {
         DWORD dwDisposition;
         lErr = RegCreateKeyExW(hkeyRoot, pszSubkey, 0, NULL, 
            REG_OPTION_NON_VOLATILE, KEY_QUERY_VALUE | KEY_SET_VALUE, 
            NULL, &m_hkeySubkey, &dwDisposition);
      }
      return(lErr);
   }

   void CloseKey() {
      if (m_hkeySubkey != NULL) { 
         ::RegCloseKey(m_hkeySubkey); 
         m_hkeySubkey = NULL;
      }
   }


public:  // Reading/writing registry value functions
   LONG GetDWORD(LPCWSTR pszValName, PDWORD pdw) const {
      DWORD cbData = sizeof(pdw);
      return(GetVal(pszValName, (PBYTE) pdw, &cbData));
   }

   LONG SetDWORD(LPCWSTR pszValName, DWORD dw) const {
      return(SetVal(pszValName, REG_DWORD, (BYTE*) &dw, sizeof(dw)));
   }


   LONG GetString(LPCWSTR pszValName, LPCWSTR psz, int nMaxSize) const {
      DWORD cbData = nMaxSize;
      return(GetVal(pszValName, (PBYTE) psz, &cbData));
   }

   LONG SetString(LPCWSTR pszValName, LPCWSTR psz) const {
      return(SetVal(pszValName, REG_SZ, (PBYTE) psz, 
         sizeof(WCHAR) * (wcslen(psz) + 1)));
   }

   
   LONG GetMultiString(LPCWSTR pszValName, LPCWSTR psz, int nMaxSize) const {
      return(GetString(pszValName, psz, nMaxSize));
   }

   LONG SetMultiString(LPCWSTR pszValName, LPCWSTR psz) const {
      for (DWORD cch = 0; psz[cch] != 0; cch += 1 + wcslen(&psz[cch])) ;
      return(SetVal(pszValName, REG_MULTI_SZ, (PBYTE) psz, 
         sizeof(WCHAR) * (cch + 1)));
   }

   
   LONG GetBinary(LPCWSTR pszValName, PBYTE pb, PDWORD pcbData) const {
      return(GetVal(pszValName, pb, pcbData));
   }

   LONG SetBinary(LPCWSTR pszValName, CONST BYTE* pb, int nSize) const {
      return(SetVal(pszValName, REG_BINARY, pb, nSize));
   }

   LONG GetSize(LPCWSTR pszValName, PDWORD pdw) {
      return(GetVal(pszValName, NULL, pdw));
   }


private:
   HKEY  m_hkeySubkey;
private:
   LONG GetVal(LPCWSTR pszValName, PBYTE pbData, PDWORD pcb) const {
      return(::RegQueryValueExW(m_hkeySubkey, pszValName, 
         NULL, NULL, pbData, pcb));
   }

   LONG SetVal(LPCWSTR pszValName, DWORD dwType, CONST BYTE *pbData, DWORD cb) const {
      return(::RegSetValueExW(m_hkeySubkey, pszValName, 
         0, dwType, pbData, cb));
   }
};


//////////////////////////////// End of File //////////////////////////////////