1257 lines
45 KiB
C++
1257 lines
45 KiB
C++
/* -*- 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 .
|
|
*/
|
|
|
|
#ifndef INCLUDED_REGISTRY_REGISTRY_HXX
|
|
#define INCLUDED_REGISTRY_REGISTRY_HXX
|
|
|
|
#include <registry/regdllapi.h>
|
|
#include <registry/regtype.h>
|
|
#include <rtl/ustring.hxx>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/** specifies a collection of function pointers which represents the complete registry C-API.
|
|
|
|
This funtions pointers are used by the C++ wrapper to call the C-API.
|
|
*/
|
|
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 *loadKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*);
|
|
RegError (REGISTRY_CALLTYPE *saveKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*);
|
|
RegError (REGISTRY_CALLTYPE *mergeKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*, sal_Bool, sal_Bool);
|
|
RegError (REGISTRY_CALLTYPE *dumpRegistry) (RegHandle, RegKeyHandle);
|
|
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*, sal_uInt32);
|
|
RegError (REGISTRY_CALLTYPE *setStringListValue) (RegKeyHandle, rtl_uString*, sal_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*, sal_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 *createLink) (RegKeyHandle, rtl_uString*, rtl_uString*);
|
|
RegError (REGISTRY_CALLTYPE *deleteLink) (RegKeyHandle, rtl_uString*);
|
|
RegError (REGISTRY_CALLTYPE *getKeyType) (RegKeyHandle, rtl_uString*, RegKeyType*);
|
|
RegError (REGISTRY_CALLTYPE *getLinkTarget) (RegKeyHandle, rtl_uString*, rtl_uString**);
|
|
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);
|
|
};
|
|
|
|
/** the API initialization function.
|
|
*/
|
|
REG_DLLPUBLIC Registry_Api* REGISTRY_CALLTYPE initRegistry_Api(void);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
|
|
class RegistryKey;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/** The Registry provides the functionality to read and write information in a registry file.
|
|
|
|
The class is implemented inline and use a C-Api.
|
|
*/
|
|
class Registry
|
|
{
|
|
public:
|
|
/** Default constructor.
|
|
*/
|
|
inline Registry();
|
|
|
|
/// Copy constructcor
|
|
inline Registry(const Registry& toCopy);
|
|
|
|
/// Destructor. The Destructor close the registry if it is open.
|
|
inline ~Registry();
|
|
|
|
/// Assign operator
|
|
inline Registry& operator = (const Registry& toAssign);
|
|
|
|
/// checks if the registry points to a valid registry data file.
|
|
inline sal_Bool isValid() const;
|
|
|
|
/** returns the access mode of the registry.
|
|
|
|
@return TRUE if the access mode is readonly else FALSE.
|
|
*/
|
|
inline sal_Bool isReadOnly() const;
|
|
|
|
/** opens the root key of the registry.
|
|
|
|
@param rRootKey reference to a RegistryKey which is filled with the rootkey.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError openRootKey(RegistryKey& rRootKey);
|
|
|
|
/// returns the name of the current registry data file.
|
|
inline OUString getName();
|
|
|
|
/** creates a new registry with the specified name and creates a root key.
|
|
|
|
@param registryName specifies the name of the new registry.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError create(const OUString& registryName);
|
|
|
|
/** opens a registry with the specified name.
|
|
|
|
If the registry already points to a valid registry, the old registry will be closed.
|
|
@param registryName specifies a registry name.
|
|
@param accessMode specifies the access mode for the registry, REG_READONLY or REG_READWRITE.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError open(const OUString& registryName,
|
|
RegAccessMode accessMode);
|
|
|
|
/// closes explicitly the current registry data file.
|
|
inline RegError close();
|
|
|
|
/** destroys a registry.
|
|
|
|
@param registryName specifies a registry name, if the name is an empty string the registry
|
|
itselfs will be destroyed.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError destroy(const OUString& registryName);
|
|
|
|
/** loads registry information from a specified file and save it under the
|
|
specified keyName.
|
|
|
|
@param rKey references a currently open key. The key which should store the registry information
|
|
is a subkey of this key.
|
|
@param keyName specifies the name of the key which stores the registry information. If keyName is
|
|
is an empty string the registry information will be saved under the key specified
|
|
by rKey.
|
|
@param regFileName specifies the file containing the registry information.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError loadKey(RegistryKey& rKey,
|
|
const OUString& keyName,
|
|
const OUString& regFileName);
|
|
|
|
/** saves the registry information of the specified key and all subkeys and save
|
|
it in the specified file.
|
|
|
|
@param rKey references a currently open key. The key which information is saved by this
|
|
function is a subkey of this key.
|
|
@param keyName specifies the name of the key which information should be stored.
|
|
If keyName is an empty string the registry information under the key specified
|
|
by rKey is saved in the specified file.
|
|
@param regFileName specifies the file containing the registry information.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError saveKey(RegistryKey& rKey,
|
|
const OUString& keyName,
|
|
const OUString& regFileName);
|
|
|
|
/** merges the registry information of the specified key with the registry
|
|
information of the specified file.
|
|
|
|
All existing keys will be extended and existing key values will be overwritten.
|
|
@param rKey references a currently open key. The key which information is merged by this
|
|
function is a subkey of this key
|
|
@param keyName specifies the name of the key which will be merged.
|
|
If keyName is an empty string the registry information under the key specified
|
|
by rKey is merged with the information from the specified file.
|
|
@param regFileName specifies the file containing the registry information.
|
|
@param bWarnings if TRUE the function returns an error if a key already exists.
|
|
@param bReport if TRUE the function reports warnings on stdout if a key already exists.
|
|
@return REG_NO_ERROR if succeeds else an error code. If it returns an error the registry will
|
|
restore the state before merging.
|
|
*/
|
|
inline RegError mergeKey(RegistryKey& rKey,
|
|
const OUString& keyName,
|
|
const OUString& regFileName,
|
|
sal_Bool bWarnings = sal_False,
|
|
sal_Bool bReport = sal_False);
|
|
|
|
/** This function reports the complete registry information of a key and all of its subkeys.
|
|
|
|
All information which are available (keynames, value types, values, ...)
|
|
will be printed to stdout for report issues only.
|
|
@param rKey references a currently open key which content will be reported.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError dumpRegistry(RegistryKey& rKey);
|
|
|
|
friend class RegistryKey;
|
|
friend class RegistryKeyArray;
|
|
friend class RegistryKeyNames;
|
|
|
|
/// returns the used registry Api.
|
|
const Registry_Api* getApi() { return m_pApi; }
|
|
protected:
|
|
|
|
/// stores the used and initialized registry Api.
|
|
const Registry_Api* m_pApi;
|
|
/// stores the handle of the underlying registry file on which most of the functions work.
|
|
RegHandle m_hImpl;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/** RegistryKeyArray represents an array of open keys.
|
|
|
|
RegistryKeyArray is a helper class to work with an array of keys.
|
|
*/
|
|
class RegistryKeyArray
|
|
{
|
|
public:
|
|
/// Default constructor
|
|
inline RegistryKeyArray();
|
|
|
|
/// Destructor, all subkeys will be closed.
|
|
inline ~RegistryKeyArray();
|
|
|
|
/// returns the open key specified by index.
|
|
inline RegistryKey getElement(sal_uInt32 index);
|
|
|
|
/// returns the length of the array.
|
|
inline sal_uInt32 getLength();
|
|
|
|
friend class RegistryKey;
|
|
protected:
|
|
/** sets the data of the key array.
|
|
|
|
@param registry specifies the registry files where the keys are located.
|
|
@param phKeys points to an array of open keys.
|
|
@param length specifies the length of the array specified by phKeys.
|
|
*/
|
|
inline void setKeyHandles(Registry& registry, RegKeyHandle* phKeys, sal_uInt32 length);
|
|
/// close all subkeys
|
|
inline RegError closeKeyHandles();
|
|
|
|
/// stores the number of open subkeys, the number of elements.
|
|
sal_uInt32 m_length;
|
|
/// stores an array of open subkeys.
|
|
RegKeyHandle* m_phKeys;
|
|
/// stores the handle to the registry file where the appropriate keys are located.
|
|
Registry m_registry;
|
|
};
|
|
|
|
|
|
/** RegistryKeyNames represents an array of key names.
|
|
|
|
RegistryKeyNames is a helper class to work with an array of key names.
|
|
*/
|
|
class RegistryKeyNames
|
|
{
|
|
public:
|
|
/// Default constructor
|
|
inline RegistryKeyNames();
|
|
|
|
/// Destructor, the internal array with key names will be deleted.
|
|
inline ~RegistryKeyNames();
|
|
|
|
/// returns the name of the key sepecified by index.
|
|
inline OUString getElement(sal_uInt32 index);
|
|
|
|
/// returns the length of the array.
|
|
inline sal_uInt32 getLength();
|
|
|
|
friend class RegistryKey;
|
|
protected:
|
|
/** sets the data of the array.
|
|
|
|
@param registry specifies the registry files where the keys are located.
|
|
@param pKeyNames points to an array of key names.
|
|
@param length specifies the length of the array specified by pKeyNames.
|
|
*/
|
|
inline void setKeyNames(Registry& registry, rtl_uString** pKeyNames, sal_uInt32 length);
|
|
/// delete the array of key names.
|
|
inline RegError freeKeyNames();
|
|
|
|
/// stores the number of key names, the number of elements.
|
|
sal_uInt32 m_length;
|
|
/// stores an array of key names.
|
|
rtl_uString** m_pKeyNames;
|
|
/// stores the handle to the registry file where the appropriate keys are located.
|
|
Registry m_registry;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/** RegistryValueList represents a value list of the specified type.
|
|
|
|
RegistryValueList is a helper class to work with a list value.
|
|
*/
|
|
template<class ValueType>
|
|
class RegistryValueList
|
|
{
|
|
public:
|
|
/// Default constructor
|
|
RegistryValueList()
|
|
: m_length(0)
|
|
, m_pValueList(NULL)
|
|
, m_valueType(RG_VALUETYPE_NOT_DEFINED)
|
|
{}
|
|
|
|
/// Destructor, the internal value list will be freed.
|
|
~RegistryValueList()
|
|
{
|
|
if (m_pValueList)
|
|
{
|
|
m_registry.getApi()->freeValueList(m_valueType, m_pValueList, m_length);
|
|
}
|
|
}
|
|
|
|
/// returns the value of the list specified by index.
|
|
ValueType getElement(sal_uInt32 index)
|
|
{
|
|
if (m_registry.isValid() && index < m_length)
|
|
{
|
|
return m_pValueList[index];
|
|
} else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/// returns the length of the list.
|
|
sal_uInt32 getLength()
|
|
{
|
|
return m_length;
|
|
}
|
|
|
|
friend class RegistryKey;
|
|
protected:
|
|
/** sets the data of the value list.
|
|
|
|
@param registry specifies the registry files where the appropriate key is located.
|
|
@param valueType specifies the type of the list values.
|
|
@param pValueList points to a value list.
|
|
@param length specifies the length of the list.
|
|
*/
|
|
void setValueList(Registry& registry, RegValueType valueType,
|
|
ValueType* pValueList, sal_uInt32 length)
|
|
{
|
|
m_length = length;
|
|
m_pValueList = pValueList;
|
|
m_valueType = valueType;
|
|
m_registry = registry;
|
|
}
|
|
|
|
/// stores the length of the list, the number of elements.
|
|
sal_uInt32 m_length;
|
|
/// stores the value list.
|
|
ValueType* m_pValueList;
|
|
/// stores the type of the list elements
|
|
RegValueType m_valueType;
|
|
/** stores the handle to the registry file where the appropriate key to this
|
|
value is located.
|
|
*/
|
|
Registry m_registry;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/** RegistryKey reads or writes information of the underlying key in a registry.
|
|
|
|
Class is inline and use a load on call C-Api.
|
|
*/
|
|
class RegistryKey
|
|
{
|
|
public:
|
|
/// Default constructor
|
|
inline RegistryKey();
|
|
|
|
/// Copy constructor
|
|
inline RegistryKey(const RegistryKey& toCopy);
|
|
|
|
/// Destructor, close the key if it references an open one.
|
|
inline ~RegistryKey();
|
|
|
|
/// Assign operator
|
|
inline RegistryKey& operator = (const RegistryKey& toAssign);
|
|
|
|
/// checks if the key points to a valid registry key.
|
|
inline sal_Bool isValid() const;
|
|
|
|
/** returns the access mode of the key.
|
|
|
|
@return TRUE if access mode is read only else FALSE.
|
|
*/
|
|
inline sal_Bool isReadOnly() const;
|
|
|
|
/// returns the full qualified name of the key beginning with the rootkey.
|
|
inline OUString getName();
|
|
|
|
/** creates a new key or opens a key if the specified key already exists.
|
|
|
|
The specified keyname is relativ to this key.
|
|
@param keyName specifies the name of the key which will be opened or created.
|
|
@param rNewKey references a RegistryKey which will be filled with the new or open key.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError createKey(const OUString& keyName,
|
|
RegistryKey& rNewKey);
|
|
|
|
/** opens the specified key.
|
|
|
|
The specified keyname is relativ to this key.
|
|
@param keyName specifies the name of the key which will be opened.
|
|
@param rOpenKey references a RegistryKey which will be filled with the open key.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError openKey(const OUString& keyName,
|
|
RegistryKey& rOpenKey);
|
|
|
|
/** opens all subkeys of the specified key.
|
|
|
|
The specified keyname is relativ to this key.
|
|
@param keyName specifies the name of the key which subkeys will be opened.
|
|
@param rSubKeys reference a RegistryKeyArray which will be filled with the open subkeys.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError openSubKeys(const OUString& keyName,
|
|
RegistryKeyArray& rSubKeys);
|
|
|
|
/** returns an array with the names of all subkeys of the specified key.
|
|
|
|
The specified keyname is relativ to this key.
|
|
@param keyName specifies the name of the key which subkey names will be returned.
|
|
@param rSubKeyNames reference a RegistryKeyNames array which will be filled with the subkey names.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError getKeyNames(const OUString& keyName,
|
|
RegistryKeyNames& rSubKeyNames);
|
|
|
|
/** closes all keys specified in the array.
|
|
|
|
@param rSubKeys reference a RegistryKeyArray which contains the open keys.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError closeSubKeys(RegistryKeyArray& rSubKeys);
|
|
|
|
/** deletes the specified key.
|
|
|
|
@param keyName specifies the name of the key which will be deleted.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError deleteKey(const OUString& keyName);
|
|
|
|
/// closes explicitly the current key
|
|
inline RegError closeKey();
|
|
|
|
/// releases the current key
|
|
inline void releaseKey();
|
|
|
|
/** sets a value of a key.
|
|
|
|
@param keyName specifies the name of the key which value will be set.
|
|
If keyName is an empty string, the value will be set for the key
|
|
specified by hKey.
|
|
@param valueType specifies the type of the value.
|
|
@param pValue points to a memory block containing the data for the value.
|
|
@param valueSize specifies the size of pData in bytes
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError setValue(const OUString& keyName,
|
|
RegValueType valueType,
|
|
RegValue pValue,
|
|
sal_uInt32 valueSize);
|
|
|
|
/** sets a long list value of a key.
|
|
|
|
@param keyName specifies the name of the key which value will be set.
|
|
If keyName is an empty string, the value will be set for the key
|
|
specified by hKey.
|
|
@param pValueList points to an array of longs containing the data for the value.
|
|
@param len specifies the length of the list (the array referenced by pValueList).
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError setLongListValue(const OUString& keyName,
|
|
sal_Int32* pValueList,
|
|
sal_uInt32 len);
|
|
|
|
/** sets an ascii list value of a key.
|
|
|
|
@param keyName specifies the name of the key which value will be set.
|
|
If keyName is an empty string, the value will be set for the key
|
|
specified by hKey.
|
|
@param pValueList points to an array of sal_Char* containing the data for the value.
|
|
@param len specifies the length of the list (the array referenced by pValueList).
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError setStringListValue(const OUString& keyName,
|
|
sal_Char** pValueList,
|
|
sal_uInt32 len);
|
|
|
|
/** sets an unicode string list value of a key.
|
|
|
|
@param keyName specifies the name of the key which value will be set.
|
|
If keyName is an empty string, the value will be set for the key
|
|
specified by hKey.
|
|
@param pValueList points to an array of sal_Unicode* containing the data for the value.
|
|
@param len specifies the length of the list (the array referenced by pValueList).
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError setUnicodeListValue(const OUString& keyName,
|
|
sal_Unicode** pValueList,
|
|
sal_uInt32 len);
|
|
|
|
/** gets info about type and size of a value.
|
|
|
|
@param keyName specifies the name of the key which value info will be returned.
|
|
If keyName is an empty string, the value info of the key
|
|
specified by hKey will be returned.
|
|
@param pValueType returns the type of the value.
|
|
@param pValueSize returns the size of the value in bytes or the length of a list value.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError getValueInfo(const OUString& keyName,
|
|
RegValueType* pValueType,
|
|
sal_uInt32* pValueSize);
|
|
|
|
/** gets the value of a key.
|
|
|
|
@param keyName specifies the name of the key which value will be returned.
|
|
If keyName is an empty string, the value is get from the key
|
|
specified by hKey.
|
|
@param pValue points to an allocated memory block receiving the data of the value.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError getValue(const OUString& keyName,
|
|
RegValue pValue);
|
|
|
|
/** gets a long list value of a key.
|
|
|
|
@param keyName specifies the name of the key which value will be returned.
|
|
If keyName is an empty string, the value is get from the key
|
|
specified by hKey.
|
|
@param rValueList references a RegistryValueList which will be filled with the long values.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError getLongListValue(const OUString& keyName,
|
|
RegistryValueList<sal_Int32>& rValueList);
|
|
|
|
/** gets an ascii list value of a key.
|
|
|
|
@param keyName specifies the name of the key which value will be returned.
|
|
If keyName is an empty string, the value is get from the key
|
|
specified by hKey.
|
|
@param rValueList references a RegistryValueList which will be filled with the ascii values.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError getStringListValue(const OUString& keyName,
|
|
RegistryValueList<sal_Char*>& rValueList);
|
|
|
|
/** gets a unicode value of a key.
|
|
|
|
@param keyName specifies the name of the key which value will be returned.
|
|
If keyName is an empty string, the value is get from the key
|
|
specified by hKey.
|
|
@param rValueList reference a RegistryValueList which will be filled with the unicode values.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError getUnicodeListValue(const OUString& keyName,
|
|
RegistryValueList<sal_Unicode*>& rValueList);
|
|
|
|
/** used to create a link.
|
|
|
|
@deprecated Links are no longer supported.
|
|
|
|
@return REG_INVALID_LINK
|
|
*/
|
|
inline RegError createLink(const OUString& linkName,
|
|
const OUString& linkTarget);
|
|
|
|
/** used to delete a link.
|
|
|
|
@deprecated Links are no longer supported.
|
|
|
|
@return REG_INVALID_LINK
|
|
*/
|
|
inline RegError deleteLink(const OUString& linkName);
|
|
|
|
/** returns the type of the specified key.
|
|
|
|
@param name specifies the name of the key or link.
|
|
@param pKeyType returns the type of the key (always RG_KEYTYPE).
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError getKeyType(const OUString& name,
|
|
RegKeyType* pKeyType) const;
|
|
|
|
/** used to return the target of a link.
|
|
|
|
@deprecated Links are no longer supported.
|
|
|
|
@return REG_INVALID_LINK
|
|
*/
|
|
inline RegError getLinkTarget(const OUString& linkName,
|
|
OUString& rLinkTarget) const;
|
|
|
|
/** resolves a keyname.
|
|
|
|
@param[in] keyName specifies the name of the key which will be resolved relative to this key.
|
|
The resolved name will be prefixed with the name of this key.
|
|
@param[in] firstLinkOnly ignored
|
|
@param[out] rResolvedName the resolved name.
|
|
@return REG_NO_ERROR if succeeds else an error code.
|
|
*/
|
|
inline RegError getResolvedKeyName(const OUString& keyName,
|
|
sal_Bool firstLinkOnly,
|
|
OUString& rResolvedName) const;
|
|
|
|
/// returns the name of the registry in which the key is defined.
|
|
inline OUString getRegistryName();
|
|
|
|
/// returns the registry in which the key is defined.
|
|
Registry getRegistry() const { return m_registry; }
|
|
|
|
friend class Registry;
|
|
public:
|
|
/// @cond INTERNAL
|
|
|
|
/** Constructor, which initialize a RegistryKey with registry and an valid key handle.
|
|
|
|
This constructor is internal only.
|
|
*/
|
|
inline RegistryKey(Registry& registry,
|
|
RegKeyHandle hKey);
|
|
|
|
/** returns the internal key handle.
|
|
*/
|
|
RegKeyHandle getKeyHandle() const { return m_hImpl; }
|
|
|
|
protected:
|
|
/** sets the internal registry on which this key should work.
|
|
*/
|
|
inline void setRegistry(Registry& registry);
|
|
|
|
/// @endcond
|
|
|
|
/// stores the registry on which this key works
|
|
Registry m_registry;
|
|
/// stores the current key handle of this key
|
|
RegKeyHandle m_hImpl;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
inline RegistryKeyArray::RegistryKeyArray()
|
|
: m_length(0)
|
|
, m_phKeys(NULL)
|
|
{
|
|
}
|
|
|
|
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()
|
|
{
|
|
return m_length;
|
|
}
|
|
|
|
inline void RegistryKeyArray::setKeyHandles(Registry& registry,
|
|
RegKeyHandle* phKeys,
|
|
sal_uInt32 length)
|
|
{
|
|
m_phKeys = phKeys;
|
|
m_length = length;
|
|
m_registry = registry;
|
|
}
|
|
|
|
inline RegError RegistryKeyArray::closeKeyHandles()
|
|
{
|
|
if (m_registry.isValid() && m_phKeys)
|
|
{
|
|
RegError ret;
|
|
ret = m_registry.m_pApi->closeSubKeys(m_phKeys, m_length);
|
|
m_registry = Registry();
|
|
m_length = 0;
|
|
m_phKeys = NULL;
|
|
return ret;
|
|
} else
|
|
return(REG_INVALID_KEY);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
inline RegistryKeyNames::RegistryKeyNames()
|
|
: m_length(0)
|
|
, m_pKeyNames(NULL)
|
|
{
|
|
}
|
|
|
|
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()
|
|
{
|
|
return m_length;
|
|
}
|
|
|
|
inline void RegistryKeyNames::setKeyNames(Registry& registry,
|
|
rtl_uString** pKeyNames,
|
|
sal_uInt32 length)
|
|
{
|
|
m_pKeyNames = pKeyNames;
|
|
m_length = length;
|
|
m_registry = registry;
|
|
}
|
|
|
|
inline RegError RegistryKeyNames::freeKeyNames()
|
|
{
|
|
if (m_registry.isValid() && m_pKeyNames)
|
|
{
|
|
RegError ret = REG_NO_ERROR;
|
|
ret = m_registry.m_pApi->freeKeyNames(m_pKeyNames, m_length);
|
|
m_registry = Registry();
|
|
m_length = 0;
|
|
m_pKeyNames = NULL;
|
|
return ret;
|
|
} else
|
|
return REG_INVALID_KEY;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
inline RegistryKey::RegistryKey()
|
|
: m_hImpl(NULL)
|
|
{ }
|
|
|
|
/// @cond INTERNAL
|
|
inline RegistryKey::RegistryKey(Registry& registry, RegKeyHandle hKey)
|
|
: m_registry(registry)
|
|
, m_hImpl(hKey)
|
|
{
|
|
if (m_hImpl)
|
|
m_registry.m_pApi->acquireKey(m_hImpl);
|
|
}
|
|
/// @endcond
|
|
|
|
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);
|
|
}
|
|
|
|
/// @cond INTERNAL
|
|
inline void RegistryKey::setRegistry(Registry& registry)
|
|
{
|
|
m_registry = registry;
|
|
}
|
|
/// @endcond
|
|
|
|
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 sal_Bool RegistryKey::isValid() const
|
|
{ return (m_hImpl != NULL); }
|
|
|
|
inline sal_Bool RegistryKey::isReadOnly() const
|
|
{
|
|
if (m_registry.isValid())
|
|
return (m_registry.m_pApi)->isKeyReadOnly(m_hImpl);
|
|
else
|
|
return sal_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) rNewKey.setRegistry(m_registry);
|
|
return ret;
|
|
} else
|
|
return REG_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) rOpenKey.setRegistry(m_registry);
|
|
return ret;
|
|
} else
|
|
return REG_INVALID_KEY;
|
|
}
|
|
|
|
inline RegError RegistryKey::openSubKeys(const OUString& keyName,
|
|
RegistryKeyArray& rSubKeys)
|
|
{
|
|
if (m_registry.isValid())
|
|
{
|
|
RegError ret = REG_NO_ERROR;
|
|
RegKeyHandle* pSubKeys;
|
|
sal_uInt32 nSubKeys;
|
|
ret = m_registry.m_pApi->openSubKeys(m_hImpl, keyName.pData,
|
|
&pSubKeys, &nSubKeys);
|
|
if ( ret )
|
|
{
|
|
return ret;
|
|
} else
|
|
{
|
|
rSubKeys.setKeyHandles(m_registry, pSubKeys, nSubKeys);
|
|
return ret;
|
|
}
|
|
} else
|
|
return REG_INVALID_KEY;
|
|
}
|
|
|
|
inline RegError RegistryKey::getKeyNames(const OUString& keyName,
|
|
RegistryKeyNames& rSubKeyNames)
|
|
{
|
|
if (m_registry.isValid())
|
|
{
|
|
RegError ret = REG_NO_ERROR;
|
|
rtl_uString** pSubKeyNames;
|
|
sal_uInt32 nSubKeys;
|
|
ret = m_registry.m_pApi->getKeyNames(m_hImpl, keyName.pData,
|
|
&pSubKeyNames, &nSubKeys);
|
|
if ( ret )
|
|
{
|
|
return ret;
|
|
} else
|
|
{
|
|
rSubKeyNames.setKeyNames(m_registry, pSubKeyNames, nSubKeys);
|
|
return ret;
|
|
}
|
|
} else
|
|
return REG_INVALID_KEY;
|
|
}
|
|
|
|
inline RegError RegistryKey::closeSubKeys(RegistryKeyArray& rSubKeys)
|
|
{
|
|
if (m_registry.isValid())
|
|
return rSubKeys.closeKeyHandles();
|
|
else
|
|
return REG_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 REG_INVALID_KEY;
|
|
}
|
|
|
|
inline RegError RegistryKey::closeKey()
|
|
{
|
|
if (m_registry.isValid())
|
|
{
|
|
RegError ret = m_registry.m_pApi->closeKey(m_hImpl);
|
|
if (!ret)
|
|
{
|
|
m_hImpl = NULL;
|
|
m_registry = Registry();
|
|
}
|
|
return ret;
|
|
} else
|
|
return REG_INVALID_KEY;
|
|
}
|
|
|
|
inline void RegistryKey::releaseKey()
|
|
{
|
|
if (m_registry.isValid() && (m_hImpl != 0))
|
|
{
|
|
m_registry.m_pApi->releaseKey(m_hImpl), m_hImpl = 0;
|
|
}
|
|
}
|
|
|
|
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 REG_INVALID_KEY;
|
|
}
|
|
|
|
inline RegError RegistryKey::setLongListValue(const OUString& keyName,
|
|
sal_Int32* pValueList,
|
|
sal_uInt32 len)
|
|
{
|
|
if (m_registry.isValid())
|
|
return m_registry.m_pApi->setLongListValue(m_hImpl, keyName.pData,
|
|
pValueList, len);
|
|
else
|
|
return REG_INVALID_KEY;
|
|
}
|
|
|
|
inline RegError RegistryKey::setStringListValue(const OUString& keyName,
|
|
sal_Char** pValueList,
|
|
sal_uInt32 len)
|
|
{
|
|
if (m_registry.isValid())
|
|
return m_registry.m_pApi->setStringListValue(m_hImpl, keyName.pData,
|
|
pValueList, len);
|
|
else
|
|
return REG_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 REG_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 REG_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 REG_INVALID_KEY;
|
|
}
|
|
|
|
inline RegError RegistryKey::getLongListValue(const OUString& keyName,
|
|
RegistryValueList<sal_Int32>& rValueList)
|
|
{
|
|
if (m_registry.isValid())
|
|
{
|
|
RegError ret = REG_NO_ERROR;
|
|
sal_Int32* pValueList;
|
|
sal_uInt32 length;
|
|
ret = m_registry.m_pApi->getLongListValue(m_hImpl, keyName.pData,
|
|
&pValueList, &length);
|
|
if ( ret )
|
|
{
|
|
return ret;
|
|
} else
|
|
{
|
|
rValueList.setValueList(m_registry, RG_VALUETYPE_LONGLIST,
|
|
pValueList, length);
|
|
return ret;
|
|
}
|
|
} else
|
|
return REG_INVALID_KEY;
|
|
}
|
|
|
|
inline RegError RegistryKey::getStringListValue(const OUString& keyName,
|
|
RegistryValueList<sal_Char*>& rValueList)
|
|
{
|
|
if (m_registry.isValid())
|
|
{
|
|
RegError ret = REG_NO_ERROR;
|
|
sal_Char** pValueList;
|
|
sal_uInt32 length;
|
|
ret = m_registry.m_pApi->getStringListValue(m_hImpl, keyName.pData,
|
|
&pValueList, &length);
|
|
if ( ret )
|
|
{
|
|
return ret;
|
|
} else
|
|
{
|
|
rValueList.setValueList(m_registry, RG_VALUETYPE_STRINGLIST,
|
|
pValueList, length);
|
|
return ret;
|
|
}
|
|
} else
|
|
return REG_INVALID_KEY;
|
|
}
|
|
|
|
inline RegError RegistryKey::getUnicodeListValue(const OUString& keyName,
|
|
RegistryValueList<sal_Unicode*>& rValueList)
|
|
{
|
|
if (m_registry.isValid())
|
|
{
|
|
RegError ret = REG_NO_ERROR;
|
|
sal_Unicode** pValueList;
|
|
sal_uInt32 length;
|
|
ret = m_registry.m_pApi->getUnicodeListValue(m_hImpl, keyName.pData,
|
|
&pValueList, &length);
|
|
if ( ret )
|
|
{
|
|
return ret;
|
|
} else
|
|
{
|
|
rValueList.setValueList(m_registry, RG_VALUETYPE_UNICODELIST,
|
|
pValueList, length);
|
|
return ret;
|
|
}
|
|
} else
|
|
return REG_INVALID_KEY;
|
|
}
|
|
|
|
inline RegError RegistryKey::createLink(const OUString& linkName,
|
|
const OUString& linkTarget)
|
|
{
|
|
if (m_registry.isValid())
|
|
return m_registry.m_pApi->createLink(m_hImpl, linkName.pData, linkTarget.pData);
|
|
else
|
|
return REG_INVALID_KEY;
|
|
}
|
|
|
|
inline RegError RegistryKey::deleteLink(const OUString& linkName)
|
|
{
|
|
if (m_registry.isValid())
|
|
return m_registry.m_pApi->deleteLink(m_hImpl, linkName.pData);
|
|
else
|
|
return REG_INVALID_KEY;
|
|
}
|
|
|
|
inline RegError RegistryKey::getKeyType(const OUString& keyName,
|
|
RegKeyType* pKeyType) const
|
|
{
|
|
if (m_registry.isValid())
|
|
return m_registry.m_pApi->getKeyType(m_hImpl, keyName.pData, pKeyType);
|
|
else
|
|
return REG_INVALID_KEY;
|
|
}
|
|
|
|
inline RegError RegistryKey::getLinkTarget(const OUString& linkName,
|
|
OUString& rLinkTarget) const
|
|
{
|
|
if (m_registry.isValid())
|
|
{
|
|
return m_registry.m_pApi->getLinkTarget(m_hImpl,
|
|
linkName.pData,
|
|
&rLinkTarget.pData);
|
|
} else
|
|
return REG_INVALID_KEY;
|
|
}
|
|
|
|
|
|
inline RegError RegistryKey::getResolvedKeyName(const OUString& keyName,
|
|
sal_Bool firstLinkOnly,
|
|
OUString& rResolvedName) const
|
|
{
|
|
if (m_registry.isValid())
|
|
return m_registry.m_pApi->getResolvedKeyName(m_hImpl,
|
|
keyName.pData,
|
|
firstLinkOnly,
|
|
&rResolvedName.pData);
|
|
else
|
|
return REG_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(NULL)
|
|
{ }
|
|
|
|
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 sal_Bool Registry::isValid() const
|
|
{ return ( m_hImpl != NULL ); }
|
|
|
|
inline sal_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)
|
|
m_hImpl = NULL;
|
|
return ret;
|
|
}
|
|
|
|
inline RegError Registry::destroy(const OUString& registryName)
|
|
{
|
|
RegError ret = m_pApi->destroyRegistry(m_hImpl, registryName.pData);
|
|
if ( !ret && registryName.isEmpty() )
|
|
m_hImpl = NULL;
|
|
return ret;
|
|
}
|
|
|
|
inline RegError Registry::loadKey(RegistryKey& rKey,
|
|
const OUString& keyName,
|
|
const OUString& regFileName)
|
|
{ return m_pApi->loadKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData); }
|
|
|
|
inline RegError Registry::saveKey(RegistryKey& rKey,
|
|
const OUString& keyName,
|
|
const OUString& regFileName)
|
|
{ return m_pApi->saveKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData); }
|
|
|
|
inline RegError Registry::mergeKey(RegistryKey& rKey,
|
|
const OUString& keyName,
|
|
const OUString& regFileName,
|
|
sal_Bool bWarnings,
|
|
sal_Bool bReport)
|
|
{ return m_pApi->mergeKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData, bWarnings, bReport); }
|
|
|
|
inline RegError Registry::dumpRegistry(RegistryKey& rKey)
|
|
{ return m_pApi->dumpRegistry(m_hImpl, rKey.m_hImpl); }
|
|
|
|
|
|
#endif
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|