cRegKeyX.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cRegKeyX_H
#define _INC_cRegKeyX_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
 
#ifdef _WIN32
#include "GrayCore/include/cRegKey.h"
#include "GrayCore/include/cString.h"
#include "GrayCore/include/cUnitTestDecl.h"
 
namespace GrayLib
{ 
        struct cRegHive
        {
 
                HKEY m_hKeyBase;
                cString m_sName;
        };
 
        class GRAYLIB_LINK cRegKeyX
                : public cRegKey
        {
                typedef cRegKey SUPER_t;
 
        public:
                static const cRegKeyName k_aNames[];    // map default HKEY values to names.
 
                cRegKeyX(HKEY hKey = HKEY_LOCAL_MACHINE) noexcept
                        : cRegKey(hKey)
                {
                }
                ~cRegKeyX() noexcept
                {
                }
                 
                static const FILECHAR_t* GRAYCALL GetNameBase(HKEY hKey) noexcept;
 
                const FILECHAR_t* get_NameBase() const noexcept
                {
                        return GetNameBase(get_HKey());
                }
 
                HRESULT OpenCreate(HKEY hKeyBase, const FILECHAR_t* pszSubKey, DWORD dwOptions = REG_OPTION_NON_VOLATILE,
                        REGSAM samDesired = KEY_ALL_ACCESS, SECURITY_ATTRIBUTES* pSa = nullptr);
 
                // Keys
 
                HRESULT SetSubKey(const FILECHAR_t* pszSubKey, const FILECHAR_t* pszValue)
                {
                        DWORD dwLenData;
                        if (pszValue == nullptr)
                        {
                                dwLenData = 0;
                        }
                        else
                        {
                                dwLenData = StrT::Len(pszValue) + 1;
                        }
#ifdef UNDER_CE
                        LSTATUS lRet = _FNF(::RegSetValueEx)(get_HKey(), pszSubKey, 0, REG_SZ, (const BYTE*)pszValue, dwLenData);
#else
                        LSTATUS lRet = _FNF(::RegSetValue)(get_HKey(), pszSubKey, REG_SZ, pszValue, dwLenData);
#endif
                        return HResult::FromWin32(lRet);
                }
 
#if (_MSC_VER>=1300) || defined(__GNUC__) // && !defined(_WINDLL)
                HRESULT DeleteKeyTree(const FILECHAR_t* pszSubKey);
#endif
 
                // Values
   
                HRESULT SetValueInit(const cRegKeyInit& val);
  
                HRESULT SetValueStr(const FILECHAR_t* lpszValueName, const FILECHAR_t* pszValue)
                {
                        ASSERT(pszValue != nullptr);
                        return SetValue(lpszValueName, REG_SZ, pszValue, StrT::Len(pszValue) + 1);
                }
 
                HRESULT QueryValueDWORD(const FILECHAR_t* lpszValueName, OUT DWORD& dwValue);
                HRESULT QueryValueStr(const FILECHAR_t* lpszValueName, OUT FILECHAR_t* pszValue, StrLen_t iSizeMax, bool bExp = false);
 
                // Used for profile type access
                HRESULT WriteValueStringExp(const FILECHAR_t* pszKey, const FILECHAR_t* pszValue)
                {
                        ASSERT(pszValue != nullptr);
                        return SetValue(pszKey, REG_EXPAND_SZ, pszValue, StrT::Len(pszValue) + 1);
                }
                HRESULT WriteValueInt(const FILECHAR_t* pszKey, int iValue)
                {
                        return SetValueDWORD(pszKey, iValue);
                }
 
                cStringT<FILECHAR_t> GetValueString(const FILECHAR_t* pszKey, const FILECHAR_t* pszValDefault = _FN(""), bool bExp = false)
                {
                        FILECHAR_t szTmp[StrT::k_LEN_MAX];
                        HRESULT hRes = QueryValueStr(pszKey, szTmp, STRMAX(szTmp), bExp);
                        if (SUCCEEDED(hRes))
                        {
                                return szTmp;
                        }
                        if (pszValDefault == nullptr)
                        {
                                return cString("");
                        }
                        return cStringT<FILECHAR_t>(pszValDefault);
                }
                int GetValueInt(const FILECHAR_t* pszKey, int iValDefault)
                {
                        DWORD dwValue;
                        HRESULT hRes = QueryValueDWORD(pszKey, dwValue);
                        if (SUCCEEDED(hRes))
                        {
                                return dwValue;
                        }
                        return iValDefault;
                }
 
                // Helper Combos
 
                static bool GRAYCALL MakeValueDWORD(OUT DWORD& rdwValue, DWORD dwType, const void* pData, DWORD dwDataSize);
                static StrLen_t GRAYCALL MakeValueStr(OUT FILECHAR_t* pszValue, StrLen_t iSizeMax, DWORD dwType, const void* pData, DWORD dwDataSize, bool bExp = false);
 
                // HRESULT SetNotifyChangeKeyValue(bool bWatchSubtree, DWORD dwNotifyFilter, HANDLE hEvent, bool fAsynchronous = true);
 
                UNITTEST_FRIEND(cRegKey);
        };
}
 
#endif // _WIN32
#endif // _INC_cRegKey_H