Registry.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
#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);
 
    __hParentKey = hParentKey;
    __hKey = NULL;
}
 
Registry::Registry(
    HKEY hParentKey,
    const String& strKey,
    REGSAM samDesired   // = KEY_READ
) __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(hParentKey != NULL);
 
    __hParentKey = hParentKey;
    __hKey = NULL;
 
    open(strKey, samDesired);
}
 
Registry::~Registry()
{
    if (opened())
        close();
 
    __DCL_ASSERT(__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(
        __hParentKey,
        strKey.data(),
        0,
        NULL,
        REG_OPTION_NON_VOLATILE,
        samDesired,
        NULL,
        &__hKey,
        &dwDisposition
    );
 
    if (lError != ERROR_SUCCESS) {
        throw(new IOException(strKey, WINAPI_ERROR(lError)));
    }
 
    __strKey = strKey;
    __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(
        __hParentKey,
        strKey.data(),
        0,
        samDesired,
        &__hKey
    );
    if (lError != ERROR_SUCCESS) {
        throw(new IOException(strKey, WINAPI_ERROR(lError)));
    }
 
    __strKey = strKey;
    __samDesired = samDesired;
}
 
void Registry::close()
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT(opened());
 
    LONG lError = RegCloseKey(__hKey);
    __hKey = NULL;
    if (lError != ERROR_SUCCESS) {
        throw(new IOException(__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(
        __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(
            __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(
        __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(
        __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(
        __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  // __WINNT__