Registry.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#if __DCL_WINDOWS
#include <windows.h>
 
#include <dcl/Object.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Registry.h>
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/core/Registry.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(Registry, Object)
 
Registry::Registry(HKEY hParentKey)
{
    __DCL_ASSERT(hParentKey != NULL);
 
    m_hParentKey = hParentKey;
    m_hKey = NULL;
}
 
Registry::Registry(
        HKEY hParentKey,
        const String& strKey,
        REGSAM samDesired   // = KEY_READ
        ) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(hParentKey != NULL);
 
    m_hParentKey = hParentKey;
    m_hKey = NULL;
 
    open(strKey, samDesired);
}
 
Registry::~Registry()
{
    if (opened())
        close();
 
    __DCL_ASSERT(m_hKey == NULL);
}
 
void Registry::create(
        const String& strKey,
        REGSAM samDesired   // = KEY_ALL_ACCESS
        ) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!strKey.isEmpty());
    if (opened())
        close();
 
    DWORD dwDisposition;
    LONG lError = ::RegCreateKeyExW(
            m_hParentKey,
            strKey.data(),
            0,
            NULL,
            REG_OPTION_NON_VOLATILE,
            samDesired,
            NULL,
            &m_hKey,
            &dwDisposition
            );
 
    if (lError != ERROR_SUCCESS)
    {
        throw(new IOException(strKey, WINAPI_ERROR(lError)));
    }
 
    m_strKey = strKey;
    m_samDesired = samDesired;
}
 
void Registry::open(
        const String& strKey,
        REGSAM samDesired // = KEY_ALL_ACCESS
        ) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(!strKey.isEmpty());
 
    if (opened())
        close();
 
    LONG lError = ::RegOpenKeyExW(
            m_hParentKey,
            strKey.data(),
            0,
            samDesired,
            &m_hKey
            );
    if (lError != ERROR_SUCCESS)
    {
        throw(new IOException(strKey, WINAPI_ERROR(lError)));
    }
 
    m_strKey = strKey;
    m_samDesired = samDesired;
}
 
void Registry::close()
        __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(opened());
 
    LONG lError = ::RegCloseKey(m_hKey);
 
    m_hKey = NULL;
 
    if (lError != ERROR_SUCCESS)
    {
        throw(new IOException(m_strKey, WINAPI_ERROR(lError)));
    }
}
 
LONG Registry::getDataInfo(const String& strName, REGISTRY_DATAINFO& info)
{
    __DCL_ASSERT(opened());
    __DCL_ASSERT(!strName.isEmpty());
 
    info.dwDataType = REG_NONE;
    info.dwDataSize = 0;
 
    return ::RegQueryValueExW(
            m_hKey,
            strName.data(),
            NULL,
            &info.dwDataType,
            NULL,
            &info.dwDataSize
            );
}
 
bool Registry::existsValue(const String& strName)
{
    REGISTRY_DATAINFO info;
    return getDataInfo(strName, info) == ERROR_SUCCESS;
}
 
String Registry::getString(const String& strName)
            __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(opened());
    __DCL_ASSERT(!strName.isEmpty());
 
    String r;
 
    REGISTRY_DATAINFO info;
    LONG lError = getDataInfo(strName, info);
    if (lError != ERROR_SUCCESS)
    {
        throw(new IOException(strName, WINAPI_ERROR(lError)));
    }
 
    if (!((info.dwDataType == REG_EXPAND_SZ || info.dwDataType == REG_SZ)))
    {
        throw(new IOException(strName, WINAPI_ERROR(ERROR_INVALID_DATA)));
    }
 
    if (info.dwDataSize > 0)
    {
        DWORD dwDataSize = info.dwDataSize;
        CharBuffer* buf = CharBuffer::create(dwDataSize);
        lError = ::RegQueryValueExW(
                m_hKey,
                strName,
                NULL,
                NULL,
                (byte_t*)buf->data(),
                &dwDataSize
                );
 
        if (lError != ERROR_SUCCESS)
        {
            buf->release();
            throw(new IOException(strName, WINAPI_ERROR(lError)));
        }
 
        buf->__dataLength = dwDataSize;
        buf->data()[buf->__dataLength] = L'\0';
        r = buf;
        buf->release();
    }
 
    return r;
}
 
int Registry::getInteger(const String& strName)
            __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(opened());
    __DCL_ASSERT(!strName.isEmpty());
 
    REGISTRY_DATAINFO info;
    LONG lError = getDataInfo(strName, info);
    if (lError != ERROR_SUCCESS)
    {
        throw(new IOException(strName, WINAPI_ERROR(lError)));
    }
 
    if (info.dwDataType != REG_DWORD)
    {
        throw(new IOException(strName, WINAPI_ERROR(ERROR_INVALID_DATA)));
    }
 
    DWORD dwData;
    DWORD dwDataSize = sizeof(dwData);
 
    lError = ::RegQueryValueExW(
            m_hKey,
            strName.data(),
            NULL,
            NULL,
            (byte_t*)&dwData,
            &dwDataSize
            );
 
    if (lError != ERROR_SUCCESS)
    {
        throw(new IOException(strName, WINAPI_ERROR(lError)));
    }
 
    return (int)dwData;
}
 
void Registry::setValue(const String& strName, const String& strValue)
            __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(opened());
    __DCL_ASSERT(!strName.isEmpty());
    __DCL_ASSERT(strValue.length() < UINT_MAX);
    DWORD len = (DWORD)strValue.length();
 
    LONG lError = ::RegSetValueExW(
            m_hKey,
            strName.data(),
            0,
            REG_SZ,
            (const byte_t*)strValue.data(),
            len + 1                              // include NULL
            );
 
    if (lError != ERROR_SUCCESS)
    {
        throw(new IOException(strName, WINAPI_ERROR(lError)));
    }
}
 
void Registry::setValue(const String& strName, int nValue)
            __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(opened());
    __DCL_ASSERT(!strName.isEmpty());
    __DCL_ASSERT(sizeof(DWORD) >= sizeof(int));
 
    DWORD dwData = (DWORD)nValue;
    LONG lError = ::RegSetValueExW(
            m_hKey,
            strName.data(),
            0,
            REG_DWORD,
            (byte_t*)&dwData,
            sizeof(DWORD)
            );
 
    if (lError != ERROR_SUCCESS)
    {
        throw(new IOException(strName, WINAPI_ERROR(lError)));
    }
}
 
bool Registry::existsKey(const String& strKeyName, HKEY hParentKey)
{
    HKEY hCurrent = NULL;
    LONG lError = ::RegOpenKeyExW(
            hParentKey,
            strKeyName.data(),
            0,
            KEY_READ,
            &hCurrent
            );
    if (lError == ERROR_SUCCESS)
    {
        ::RegCloseKey(hCurrent);
        return true;
    }
    return false;
}
 
__DCL_END_NAMESPACE
 
#endif      // __DCL_WINDOWS