registry.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

#pragma once

#include <registry/regdllapi.h>
#include <registry/regtype.h>
#include <rtl/ustring.hxx>

extern "C" {

struct Registry_Api
{
    void        (REGISTRY_CALLTYPE *acquire)            (RegHandle);
    void        (REGISTRY_CALLTYPE *release)            (RegHandle);
    sal_Bool    (REGISTRY_CALLTYPE *isReadOnly)         (RegHandle);
    RegError    (REGISTRY_CALLTYPE *openRootKey)        (RegHandle, RegKeyHandle*);
    RegError    (REGISTRY_CALLTYPE *getName)            (RegHandle, rtl_uString**);
    RegError    (REGISTRY_CALLTYPE *createRegistry)     (rtl_uString*, RegHandle*);
    RegError    (REGISTRY_CALLTYPE *openRegistry)       (rtl_uString*, RegHandle*, RegAccessMode);
    RegError    (REGISTRY_CALLTYPE *closeRegistry)      (RegHandle);
    RegError    (REGISTRY_CALLTYPE *destroyRegistry)    (RegHandle, rtl_uString*);
    RegError    (REGISTRY_CALLTYPE *mergeKey)           (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*, sal_Bool, sal_Bool);
    void        (REGISTRY_CALLTYPE *acquireKey)         (RegKeyHandle);
    void        (REGISTRY_CALLTYPE *releaseKey)         (RegKeyHandle);
    sal_Bool    (REGISTRY_CALLTYPE *isKeyReadOnly)      (RegKeyHandle);
    RegError    (REGISTRY_CALLTYPE *getKeyName)         (RegKeyHandle, rtl_uString**);
    RegError    (REGISTRY_CALLTYPE *createKey)          (RegKeyHandle, rtl_uString*, RegKeyHandle*);
    RegError    (REGISTRY_CALLTYPE *openKey)            (RegKeyHandle, rtl_uString*, RegKeyHandle*);
    RegError    (REGISTRY_CALLTYPE *openSubKeys)        (RegKeyHandle, rtl_uString*, RegKeyHandle**, sal_uInt32*);
    RegError    (REGISTRY_CALLTYPE *closeSubKeys)       (RegKeyHandle*, sal_uInt32);
    RegError    (REGISTRY_CALLTYPE *deleteKey)          (RegKeyHandle, rtl_uString*);
    RegError    (REGISTRY_CALLTYPE *closeKey)           (RegKeyHandle);
    RegError    (REGISTRY_CALLTYPE *setValue)           (RegKeyHandle, rtl_uString*, RegValueType, RegValue, sal_uInt32);
    RegError    (REGISTRY_CALLTYPE *setLongListValue)   (RegKeyHandle, rtl_uString*, sal_Int32 const *, sal_uInt32);
    RegError    (REGISTRY_CALLTYPE *setStringListValue) (RegKeyHandle, rtl_uString*, char**, sal_uInt32);
    RegError    (REGISTRY_CALLTYPE *setUnicodeListValue)(RegKeyHandle, rtl_uString*, sal_Unicode**, sal_uInt32);
    RegError    (REGISTRY_CALLTYPE *getValueInfo)       (RegKeyHandle, rtl_uString*, RegValueType*, sal_uInt32*);
    RegError    (REGISTRY_CALLTYPE *getValue)           (RegKeyHandle, rtl_uString*, RegValue);
    RegError    (REGISTRY_CALLTYPE *getLongListValue)   (RegKeyHandle, rtl_uString*, sal_Int32**, sal_uInt32*);
    RegError    (REGISTRY_CALLTYPE *getStringListValue) (RegKeyHandle, rtl_uString*, char***, sal_uInt32*);
    RegError    (REGISTRY_CALLTYPE *getUnicodeListValue)(RegKeyHandle, rtl_uString*, sal_Unicode***, sal_uInt32*);
    RegError    (REGISTRY_CALLTYPE *freeValueList)      (RegValueType, RegValue, sal_uInt32);
    RegError    (REGISTRY_CALLTYPE *getResolvedKeyName) (RegKeyHandle, rtl_uString*, sal_Bool, rtl_uString**);
    RegError    (REGISTRY_CALLTYPE *getKeyNames)        (RegKeyHandle, rtl_uString*, rtl_uString***, sal_uInt32*);
    RegError    (REGISTRY_CALLTYPE *freeKeyNames)       (rtl_uString**, sal_uInt32);
};

REG_DLLPUBLIC Registry_Api* REGISTRY_CALLTYPE initRegistry_Api();

}

class RegistryKey;


class Registry final
{
public:
    inline Registry();

    inline Registry(const Registry& toCopy);

    Registry(Registry && other) noexcept : m_pApi(other.m_pApi), m_hImpl(other.m_hImpl)
    { other.m_hImpl = nullptr; }

    inline ~Registry();

    inline Registry& operator = (const Registry& toAssign);

    Registry & operator =(Registry && other) {
        if (m_hImpl != nullptr) {
            m_pApi->release(m_hImpl);
        }
        m_hImpl = other.m_hImpl;
        other.m_hImpl = nullptr;
        return *this;
    }

    inline bool isValid() const;

    inline bool     isReadOnly() const;

    inline RegError openRootKey(RegistryKey& rRootKey);

    inline OUString getName();

    inline RegError create(const OUString& registryName);

    inline RegError open(const OUString& registryName,
                            RegAccessMode accessMode);

    inline RegError close();

    inline RegError destroy(const OUString& registryName);

    inline RegError mergeKey(RegistryKey& rKey,
                                const OUString& keyName,
                                const OUString& regFileName,
                                bool bReport);

    friend class RegistryKey;
    friend class RegistryKeyArray;
    friend class RegistryKeyNames;

    const Registry_Api* getApi() const { return m_pApi; }

private:
    const Registry_Api*                          m_pApi;
    RegHandle                                    m_hImpl;
};


class RegistryKeyArray
{
public:
    inline RegistryKeyArray();

    inline ~RegistryKeyArray();

    inline RegistryKey getElement(sal_uInt32 index);

    inline sal_uInt32 getLength() const;

    friend class RegistryKey;
protected:
    inline void setKeyHandles(Registry const & registry, RegKeyHandle* phKeys, sal_uInt32 length);
private:
    sal_uInt32      m_length;
    RegKeyHandle*   m_phKeys;
    Registry        m_registry;
};


class RegistryKeyNames
{
public:
    inline RegistryKeyNames();

    inline ~RegistryKeyNames();

    inline OUString getElement(sal_uInt32 index);

    inline sal_uInt32 getLength() const;

    friend class RegistryKey;
protected:
    inline void setKeyNames(Registry const & registry, rtl_uString** pKeyNames, sal_uInt32 length);
private:
    sal_uInt32      m_length;
    rtl_uString**   m_pKeyNames;
    Registry        m_registry;
};


template<class ValueType>
class RegistryValueList final
{
public:
    RegistryValueList()
        : m_length(0)
        , m_pValueList(nullptr)
        , m_valueType(RegValueType::NOT_DEFINED)
        {}

    ~RegistryValueList()
    {
        if (m_pValueList)
        {
            m_registry.getApi()->freeValueList(m_valueType, m_pValueList, m_length);
        }
    }

    ValueType getElement(sal_uInt32 index)
    {
        if (m_registry.isValid() && index < m_length)
        {
            return m_pValueList[index];
        } else
        {
            return 0;
        }
    }

    sal_uInt32 getLength()
    {
        return m_length;
    }

    friend class RegistryKey;

private:
    void setValueList(const Registry& registry, RegValueType valueType,
                      ValueType* pValueList, sal_uInt32 length)
    {
        m_length = length;
        m_pValueList = pValueList;
        m_valueType = valueType;
        m_registry = registry;
    }

    sal_uInt32      m_length;
    ValueType*      m_pValueList;
    RegValueType    m_valueType;
    Registry        m_registry;
};


class RegistryKey
{
public:
    inline RegistryKey();

    inline RegistryKey(const RegistryKey& toCopy);

    inline ~RegistryKey();

    inline RegistryKey& operator = (const RegistryKey& toAssign);

    inline bool isValid() const;

    inline bool     isReadOnly() const;

    inline OUString getName();

    inline RegError createKey(const OUString& keyName,
                              RegistryKey& rNewKey);

    inline RegError openKey(const OUString& keyName,
                              RegistryKey& rOpenKey);

    inline RegError openSubKeys(const OUString& keyName,
                                    RegistryKeyArray& rSubKeys);

    inline RegError getKeyNames(const OUString& keyName,
                                    RegistryKeyNames& rSubKeyNames);

    inline RegError deleteKey(const OUString& keyName);

    inline RegError closeKey();

    inline void releaseKey();

    inline RegError setValue(const OUString& keyName,
                                RegValueType valueType,
                                RegValue pValue,
                                sal_uInt32 valueSize);

    inline RegError setLongListValue(const OUString& keyName,
                                         sal_Int32 const * pValueList,
                                         sal_uInt32 len);

    inline RegError setStringListValue(const OUString& keyName,
                                           char** pValueList,
                                           sal_uInt32 len);

    inline RegError setUnicodeListValue(const OUString& keyName,
                                            sal_Unicode** pValueList,
                                              sal_uInt32 len);

    inline RegError getValueInfo(const OUString& keyName,
                                    RegValueType* pValueType,
                                    sal_uInt32* pValueSize);

    inline RegError getValue(const OUString& keyName,
                                RegValue pValue);

    inline RegError getLongListValue(const OUString& keyName,
                                          RegistryValueList<sal_Int32>& rValueList);

    inline RegError getStringListValue(const OUString& keyName,
                                           RegistryValueList<char*>& rValueList);

    inline RegError getUnicodeListValue(const OUString& keyName,
                                              RegistryValueList<sal_Unicode*>& rValueList);

    inline RegError getResolvedKeyName(const OUString& keyName,
                                           OUString& rResolvedName) const;

    inline OUString getRegistryName();

    friend class Registry;
public:

    inline RegistryKey(Registry const & registry,
                       RegKeyHandle hKey);

protected:
    inline void setRegistry(Registry const & registry);


    Registry        m_registry;
    RegKeyHandle    m_hImpl;
};


inline RegistryKeyArray::RegistryKeyArray()
    : m_length(0)
    , m_phKeys(nullptr)
{
}

inline RegistryKeyArray::~RegistryKeyArray()
{
    if (m_phKeys)
        m_registry.m_pApi->closeSubKeys(m_phKeys, m_length);
}

inline RegistryKey RegistryKeyArray::getElement(sal_uInt32 index)
{
    if (m_registry.isValid() && index < m_length)
        return RegistryKey(m_registry, m_phKeys[index]);
    else
        return RegistryKey();
}

inline sal_uInt32 RegistryKeyArray::getLength() const
{
    return m_length;
}

inline void RegistryKeyArray::setKeyHandles(Registry const & registry,
                                            RegKeyHandle* phKeys,
                                            sal_uInt32 length)
{
    m_phKeys = phKeys;
    m_length = length;
    m_registry = registry;
}

inline RegistryKeyNames::RegistryKeyNames()
    : m_length(0)
    , m_pKeyNames(nullptr)
{
}

inline RegistryKeyNames::~RegistryKeyNames()
{
    if (m_pKeyNames)
        m_registry.m_pApi->freeKeyNames(m_pKeyNames, m_length);
}

inline OUString RegistryKeyNames::getElement(sal_uInt32 index)
{

    if (m_pKeyNames && index < m_length)
        return m_pKeyNames[index];
    else
        return OUString();
}

inline sal_uInt32 RegistryKeyNames::getLength() const
{
    return m_length;
}

inline void RegistryKeyNames::setKeyNames(Registry const & registry,
                                          rtl_uString** pKeyNames,
                                          sal_uInt32 length)
{
    m_pKeyNames = pKeyNames;
    m_length = length;
    m_registry = registry;
}

inline RegistryKey::RegistryKey()
    : m_hImpl(nullptr)
    { }

inline RegistryKey::RegistryKey(Registry const & registry, RegKeyHandle hKey)
    : m_registry(registry)
    , m_hImpl(hKey)
    {
        if (m_hImpl)
            m_registry.m_pApi->acquireKey(m_hImpl);
    }

inline RegistryKey::RegistryKey(const RegistryKey& toCopy)
    : m_registry(toCopy.m_registry)
    , m_hImpl(toCopy.m_hImpl)
    {
        if (m_hImpl)
            m_registry.m_pApi->acquireKey(m_hImpl);
    }

inline void RegistryKey::setRegistry(Registry const & registry)
    {
        m_registry = registry;
    }

inline RegistryKey::~RegistryKey()
    {
        if (m_hImpl)
            m_registry.m_pApi->releaseKey(m_hImpl);
    }

inline RegistryKey& RegistryKey::operator = (const RegistryKey& toAssign)
{
    m_registry = toAssign.m_registry;

    if (toAssign.m_hImpl)
        m_registry.m_pApi->acquireKey(toAssign.m_hImpl);
    if (m_hImpl)
        m_registry.m_pApi->releaseKey(m_hImpl);
    m_hImpl = toAssign.m_hImpl;

    return *this;
}

inline bool RegistryKey::isValid() const
    {  return (m_hImpl != nullptr); }

inline bool RegistryKey::isReadOnly() const
    {
        if  (m_registry.isValid())
            return m_registry.m_pApi->isKeyReadOnly(m_hImpl);
        else
            return false;
    }

inline OUString RegistryKey::getName()
    {
        OUString sRet;
        if (m_registry.isValid())
            m_registry.m_pApi->getKeyName(m_hImpl, &sRet.pData);
        return sRet;
    }

inline RegError RegistryKey::createKey(const OUString& keyName,
                                          RegistryKey& rNewKey)
    {
        if (rNewKey.isValid()) rNewKey.closeKey();
        if (m_registry.isValid())
        {
            RegError ret = m_registry.m_pApi->createKey(m_hImpl, keyName.pData, &rNewKey.m_hImpl);
            if (ret == RegError::NO_ERROR) rNewKey.setRegistry(m_registry);
            return ret;
        } else
            return RegError::INVALID_KEY;
    }

inline RegError RegistryKey::openKey(const OUString& keyName,
                                     RegistryKey& rOpenKey)
    {
        if (rOpenKey.isValid()) rOpenKey.closeKey();
        if (m_registry.isValid())
        {
            RegError ret = m_registry.m_pApi->openKey(m_hImpl, keyName.pData,
                                                    &rOpenKey.m_hImpl);
            if (ret == RegError::NO_ERROR) rOpenKey.setRegistry(m_registry);
            return ret;
        } else
            return RegError::INVALID_KEY;
    }

inline RegError RegistryKey::openSubKeys(const OUString& keyName,
                                         RegistryKeyArray& rSubKeys)
    {
        if (m_registry.isValid())
        {
            RegError        ret = RegError::NO_ERROR;
            RegKeyHandle*   pSubKeys;
            sal_uInt32      nSubKeys;
            ret = m_registry.m_pApi->openSubKeys(m_hImpl, keyName.pData,
                                                      &pSubKeys, &nSubKeys);
            if ( ret != RegError::NO_ERROR)
            {
                return ret;
            } else
            {
                rSubKeys.setKeyHandles(m_registry, pSubKeys, nSubKeys);
                return ret;
            }
        } else
            return RegError::INVALID_KEY;
    }

inline RegError RegistryKey::getKeyNames(const OUString& keyName,
                                             RegistryKeyNames& rSubKeyNames)
    {
        if (m_registry.isValid())
        {
            RegError        ret = RegError::NO_ERROR;
            rtl_uString**   pSubKeyNames;
            sal_uInt32      nSubKeys;
            ret = m_registry.m_pApi->getKeyNames(m_hImpl, keyName.pData,
                                                  &pSubKeyNames, &nSubKeys);
            if ( ret != RegError::NO_ERROR)
            {
                return ret;
            } else
            {
                rSubKeyNames.setKeyNames(m_registry, pSubKeyNames, nSubKeys);
                return ret;
            }
        } else
            return RegError::INVALID_KEY;
    }

inline RegError RegistryKey::deleteKey(const OUString& keyName)
    {
        if (m_registry.isValid())
            return m_registry.m_pApi->deleteKey(m_hImpl, keyName.pData);
        else
            return RegError::INVALID_KEY;
    }

inline RegError RegistryKey::closeKey()
    {
        if (m_registry.isValid())
        {
            RegError ret = m_registry.m_pApi->closeKey(m_hImpl);
            if (ret == RegError::NO_ERROR)
            {
                m_hImpl = nullptr;
                m_registry = Registry();
            }
            return ret;
        } else
            return RegError::INVALID_KEY;
    }

inline void RegistryKey::releaseKey()
{
    if (m_registry.isValid() && (m_hImpl != nullptr))
    {
        m_registry.m_pApi->releaseKey(m_hImpl);
        m_hImpl = nullptr;
    }
}

inline RegError RegistryKey::setValue(const OUString& keyName,
                                              RegValueType valueType,
                                           RegValue pValue,
                                              sal_uInt32 valueSize)
    {
        if (m_registry.isValid())
            return m_registry.m_pApi->setValue(m_hImpl, keyName.pData, valueType,
                                                pValue, valueSize);
        else
            return RegError::INVALID_KEY;
    }

inline RegError RegistryKey::setLongListValue(const OUString& keyName,
                                                  sal_Int32 const * pValueList,
                                                  sal_uInt32 len)
    {
        if (m_registry.isValid())
            return m_registry.m_pApi->setLongListValue(m_hImpl, keyName.pData,
                                                           pValueList, len);
        else
            return RegError::INVALID_KEY;
    }

inline RegError RegistryKey::setStringListValue(const OUString& keyName,
                                                   char** pValueList,
                                                   sal_uInt32 len)
    {
        if (m_registry.isValid())
            return m_registry.m_pApi->setStringListValue(m_hImpl, keyName.pData,
                                                            pValueList, len);
        else
            return RegError::INVALID_KEY;
    }

inline RegError RegistryKey::setUnicodeListValue(const OUString& keyName,
                                                        sal_Unicode** pValueList,
                                                        sal_uInt32 len)
    {
        if (m_registry.isValid())
            return m_registry.m_pApi->setUnicodeListValue(m_hImpl, keyName.pData,
                                                              pValueList, len);
        else
            return RegError::INVALID_KEY;
    }

inline RegError RegistryKey::getValueInfo(const OUString& keyName,
                                                  RegValueType* pValueType,
                                                  sal_uInt32* pValueSize)
    {
        if (m_registry.isValid())
            return m_registry.m_pApi->getValueInfo(m_hImpl, keyName.pData, pValueType, pValueSize);
        else
            return RegError::INVALID_KEY;
    }

inline RegError RegistryKey::getValue(const OUString& keyName,
                                        RegValue pValue)
    {
        if (m_registry.isValid())
            return m_registry.m_pApi->getValue(m_hImpl, keyName.pData, pValue);
        else
            return RegError::INVALID_KEY;
    }

inline RegError RegistryKey::getLongListValue(const OUString& keyName,
                                              RegistryValueList<sal_Int32>& rValueList)
    {
        if (m_registry.isValid())
        {
            RegError    ret = RegError::NO_ERROR;
            sal_Int32*  pValueList;
            sal_uInt32  length;
            ret = m_registry.m_pApi->getLongListValue(m_hImpl, keyName.pData,
                                                      &pValueList, &length);
            if ( ret != RegError::NO_ERROR)
            {
                return ret;
            } else
            {
                rValueList.setValueList(m_registry, RegValueType::LONGLIST,
                                        pValueList, length);
                return ret;
            }
        } else
            return RegError::INVALID_KEY;
    }

inline RegError RegistryKey::getStringListValue(const OUString& keyName,
                                                      RegistryValueList<char*>& rValueList)
    {
        if (m_registry.isValid())
        {
            RegError    ret = RegError::NO_ERROR;
            char**  pValueList;
            sal_uInt32  length;
            ret = m_registry.m_pApi->getStringListValue(m_hImpl, keyName.pData,
                                                      &pValueList, &length);
            if ( ret != RegError::NO_ERROR )
            {
                return ret;
            } else
            {
                rValueList.setValueList(m_registry, RegValueType::STRINGLIST,
                                        pValueList, length);
                return ret;
            }
        } else
            return RegError::INVALID_KEY;
    }

inline RegError RegistryKey::getUnicodeListValue(const OUString& keyName,
                                              RegistryValueList<sal_Unicode*>& rValueList)
    {
        if (m_registry.isValid())
        {
            RegError        ret = RegError::NO_ERROR;
            sal_Unicode**   pValueList;
            sal_uInt32      length;
            ret = m_registry.m_pApi->getUnicodeListValue(m_hImpl, keyName.pData,
                                                      &pValueList, &length);
            if ( ret != RegError::NO_ERROR )
            {
                return ret;
            } else
            {
                rValueList.setValueList(m_registry, RegValueType::UNICODELIST,
                                        pValueList, length);
                return ret;
            }
        } else
            return RegError::INVALID_KEY;
    }

inline RegError RegistryKey::getResolvedKeyName(const OUString& keyName,
                                                      OUString& rResolvedName) const
    {
        if (m_registry.isValid())
            return m_registry.m_pApi->getResolvedKeyName(m_hImpl,
                                                         keyName.pData,
                                                         true,
                                                         &rResolvedName.pData);
        else
            return RegError::INVALID_KEY;
    }

inline OUString RegistryKey::getRegistryName()
    {
        if (m_registry.isValid())
        {
            return m_registry.getName();
        } else
            return OUString();
    }


inline Registry::Registry()
    : m_pApi(initRegistry_Api())
    , m_hImpl(nullptr)
    { }

inline Registry::Registry(const Registry& toCopy)
    : m_pApi(toCopy.m_pApi)
    , m_hImpl(toCopy.m_hImpl)
    {
        if (m_hImpl)
            m_pApi->acquire(m_hImpl);
    }


inline Registry::~Registry()
    {
        if (m_hImpl)
            m_pApi->release(m_hImpl);
    }

inline Registry& Registry::operator = (const Registry& toAssign)
{
    if (toAssign.m_hImpl)
        toAssign.m_pApi->acquire(toAssign.m_hImpl);
    if (m_hImpl)
        m_pApi->release(m_hImpl);

    m_pApi  = toAssign.m_pApi;
    m_hImpl = toAssign.m_hImpl;

    return *this;
}

inline bool Registry::isValid() const
    {  return ( m_hImpl != nullptr ); }

inline bool Registry::isReadOnly() const
    {  return m_pApi->isReadOnly(m_hImpl); }

inline RegError Registry::openRootKey(RegistryKey& rRootKey)
    {
        rRootKey.setRegistry(*this);
        return m_pApi->openRootKey(m_hImpl, &rRootKey.m_hImpl);
    }

inline OUString Registry::getName()
    {
        OUString sRet;
        m_pApi->getName(m_hImpl, &sRet.pData);
        return sRet;
    }

inline RegError Registry::create(const OUString& registryName)
    {
        if (m_hImpl)
            m_pApi->release(m_hImpl);
        return m_pApi->createRegistry(registryName.pData, &m_hImpl);
    }

inline RegError Registry::open(const OUString& registryName,
                                  RegAccessMode accessMode)
    {
        if (m_hImpl)
            m_pApi->release(m_hImpl);
        return m_pApi->openRegistry(registryName.pData, &m_hImpl, accessMode);
    }

inline RegError Registry::close()
    {
        RegError ret = m_pApi->closeRegistry(m_hImpl);
        if (ret == RegError::NO_ERROR)
            m_hImpl = nullptr;
        return ret;
    }

inline RegError Registry::destroy(const OUString& registryName)
    {
        RegError ret = m_pApi->destroyRegistry(m_hImpl, registryName.pData);
        if ( ret == RegError::NO_ERROR && registryName.isEmpty() )
            m_hImpl = nullptr;
        return ret;
    }

inline RegError Registry::mergeKey(RegistryKey& rKey,
                                         const OUString& keyName,
                                         const OUString& regFileName,
                                         bool bReport)
    {  return m_pApi->mergeKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData, false/*bWarnings*/, bReport); }

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */