diff options
Diffstat (limited to 'include/registry/registry.hxx')
| -rw-r--r-- | include/registry/registry.hxx | 1257 |
1 files changed, 1257 insertions, 0 deletions
diff --git a/include/registry/registry.hxx b/include/registry/registry.hxx new file mode 100644 index 000000000000..d165c594adff --- /dev/null +++ b/include/registry/registry.hxx @@ -0,0 +1,1257 @@ +/* -*- 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 _REGISTRY_REGISTRY_HXX_ +#define _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: */ |