cRegKey.h

Go to the documentation of this file.

//
//
#ifndef _INC_cRegKey_H
#define _INC_cRegKey_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cHandlePtr.h"
#include "FileName.h"
#include "HResult.h"
 
#ifdef _WIN32
 
#ifndef HKEY_LOCAL_MACHINE      
#define HKEY_LOCAL_MACHINE      ((HKEY)(ULONG_PTR)((LONG)0x80000002))
#endif  // HKEY_LOCAL_MACHINE
#ifndef HKEY_CURRENT_USER
#define HKEY_CURRENT_USER       ((HKEY)(ULONG_PTR)((LONG)0x80000001))
#endif  // HKEY_LOCAL_MACHINE
 
namespace Gray
{
        struct cRegKeyName
        {
                HKEY m_hKey; 
                const FILECHAR_t* m_pszRegPath; 
        };
        class cRegKeyInit
        {
        public:
                cRegKeyName m_Key;
                const FILECHAR_t* m_pszKeyName; 
                void* m_pValue;         
                DWORD m_dwType;         
 
        public:
                bool isEndMarker() const noexcept
                {
                        return m_Key.m_hKey == HANDLEPTR_NULL;  // end of an array of values.
                }
                bool isRegValue() const noexcept
                {
                        // ASSUME m_dwType is set as well.
                        return m_pszKeyName != nullptr;
                }
        };
 
        class cRegKey   // not GRAYCORE_LINK since its inline
                : public cHandlePtr < HKEY >
        {
                typedef cHandlePtr<HKEY> SUPER_t;
 
        public:
                cRegKey(HKEY hKey = HKEY_LOCAL_MACHINE) noexcept
                        : cHandlePtr<HKEY>(hKey)
                {
                }
                ~cRegKey() noexcept
                {
                }
 
                HKEY get_HKey() const noexcept
                {
                        return get_Handle();
                }
 
                static inline bool IsKeyBase(HKEY hKey) noexcept
                {
                        return (((size_t)hKey) & ((size_t)HKEY_CLASSES_ROOT)) == ((size_t)HKEY_CLASSES_ROOT);
                }
                bool isKeyBase() const noexcept
                {
                        return IsKeyBase(get_HKey());
                }
 
                bool isKeyOpen() const noexcept
                {
                        if (isKeyBase())
                                return false;
                        return SUPER_t::isValidHandle();
                }
 
                void Attach(HKEY hKey)
                {
                        SUPER_t::AttachHandle(hKey);
                }
                HKEY Detach() noexcept
                {
                        HKEY h = get_HKey();
                        ref_Handle() = HKEY_LOCAL_MACHINE;
                        return h;
                }
 
                HRESULT Open(HKEY hKeyBase, const FILECHAR_t* pszSubKey, REGSAM samDesired = KEY_READ)
                {
                        CloseHandle();
                        const LSTATUS lRet = _FNF(::RegOpenKeyEx)(hKeyBase, pszSubKey, 0, samDesired, &ref_Handle());
                        return HResult::FromWin32(lRet);
                }
 
                HRESULT OpenBase(const FILECHAR_t* pszSubKey, REGSAM samDesired = KEY_READ)
                {
                        ASSERT(isKeyBase());
                        return Open(get_HKey(), pszSubKey, samDesired);
                }
 
                HRESULT FlushX() noexcept
                {
                        const LSTATUS lRet = ::RegFlushKey(get_Handle());
                        return HResult::FromWin32(lRet);
                }
 
                // Keys
 
                HRESULT DeleteKey(const FILECHAR_t* pszSubKey) noexcept
                {
                        const LSTATUS lRet = _FNF(::RegDeleteKey)(get_HKey(), pszSubKey);
                        return HResult::FromWin32(lRet);
                }
 
                HRESULT EnumKey(DWORD dwIndex, OUT FILECHAR_t* pszNameRet, DWORD& dwSizeName) noexcept
                {
                        const LSTATUS lRet = _FNF(::RegEnumKeyEx)(get_HKey(), dwIndex, pszNameRet, &dwSizeName,
                                nullptr, nullptr, nullptr, nullptr);
                        return HResult::FromWin32(lRet);
                }
 
                // Values
 
                HRESULT EnumValue(DWORD dwIndex, FILECHAR_t* pszNameRet, DWORD& dwSizeName, DWORD* pdwTypeRet = nullptr, void* pDataRet = nullptr, DWORD* pdwSizeData = nullptr) noexcept
                {
                        const LSTATUS lRet = _FNF(::RegEnumValue)(get_HKey(), dwIndex, pszNameRet, &dwSizeName, nullptr,
                                pdwTypeRet, (LPBYTE)pDataRet, pdwSizeData);
                        return HResult::FromWin32(lRet);
                }
                HRESULT DeleteValue(const FILECHAR_t* pszSubKey) noexcept
                {
                        const LSTATUS lRet = _FNF(::RegDeleteValue)(get_HKey(), pszSubKey);
                        return HResult::FromWin32(lRet);
                }
                HRESULT SetValue(const FILECHAR_t* pszValueName, DWORD dwType, const void* pData, DWORD dwDataSize) noexcept
                {
 
                        const LSTATUS lRet = _FNF(::RegSetValueEx)(get_HKey(), pszValueName,
                                0, dwType, (LPBYTE)pData, dwDataSize);
                        return HResult::FromWin32(lRet);
                }
 
                HRESULT QueryValue(const FILECHAR_t* pszValueName, OUT DWORD& rdwType, OUT void* pData, OUT DWORD& rdwDataSize) noexcept
                {
                        const LSTATUS lRet = _FNF(::RegQueryValueEx)(get_HKey(), pszValueName, nullptr, &rdwType, (LPBYTE)pData, &rdwDataSize);
                        return HResult::FromWin32(lRet);
                }
 
                HRESULT SetValueDWORD(const FILECHAR_t* lpszValueName, DWORD dwValue)
                {
                        ASSERT(lpszValueName != nullptr);
                        return SetValue(lpszValueName, REG_DWORD, &dwValue, sizeof(DWORD));
                }
 
                // Helper Combos
                HRESULT OpenQuerySubKey(HKEY hKeyBase, const FILECHAR_t* pszSubKey, FILECHAR_t* pData, DWORD dwDataSize = _MAX_PATH - 1)
                {
                        const HRESULT hRes = Open(hKeyBase, pszSubKey, KEY_QUERY_VALUE);
                        if (FAILED(hRes))
                                return hRes;
                        DWORD dwType = REG_SZ;  // always REG_SZ or REG_EXPAND_SZ
                        return QueryValue(nullptr, dwType, pData, OUT dwDataSize);
                }
        };
 
        template <> inline void cHandlePtr<HKEY>::CloseHandle(HKEY h) // static
        {
                if (cRegKey::IsKeyBase(h)) // never close base keys
                        return;
                ::RegCloseKey(h); // ignored BOOL return.
        }
}
 
#endif
#endif