UDK 3.2.7 C/C++ API Reference
|
00001 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ 00002 /************************************************************************* 00003 * 00004 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 00005 * 00006 * Copyright 2000, 2010 Oracle and/or its affiliates. 00007 * 00008 * OpenOffice.org - a multi-platform office productivity suite 00009 * 00010 * This file is part of OpenOffice.org. 00011 * 00012 * OpenOffice.org is free software: you can redistribute it and/or modify 00013 * it under the terms of the GNU Lesser General Public License version 3 00014 * only, as published by the Free Software Foundation. 00015 * 00016 * OpenOffice.org is distributed in the hope that it will be useful, 00017 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00018 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00019 * GNU Lesser General Public License version 3 for more details 00020 * (a copy is included in the LICENSE file that accompanied this code). 00021 * 00022 * You should have received a copy of the GNU Lesser General Public License 00023 * version 3 along with OpenOffice.org. If not, see 00024 * <http://www.openoffice.org/license.html> 00025 * for a copy of the LGPLv3 License. 00026 * 00027 ************************************************************************/ 00028 00029 #ifndef _REGISTRY_REGISTRY_HXX_ 00030 #define _REGISTRY_REGISTRY_HXX_ 00031 00032 #include <registry/regdllapi.h> 00033 #include <registry/regtype.h> 00034 #include <rtl/ustring.hxx> 00035 00036 #ifdef __cplusplus 00037 extern "C" { 00038 #endif 00039 00044 struct Registry_Api 00045 { 00046 void (REGISTRY_CALLTYPE *acquire) (RegHandle); 00047 void (REGISTRY_CALLTYPE *release) (RegHandle); 00048 sal_Bool (REGISTRY_CALLTYPE *isReadOnly) (RegHandle); 00049 RegError (REGISTRY_CALLTYPE *openRootKey) (RegHandle, RegKeyHandle*); 00050 RegError (REGISTRY_CALLTYPE *getName) (RegHandle, rtl_uString**); 00051 RegError (REGISTRY_CALLTYPE *createRegistry) (rtl_uString*, RegHandle*); 00052 RegError (REGISTRY_CALLTYPE *openRegistry) (rtl_uString*, RegHandle*, RegAccessMode); 00053 RegError (REGISTRY_CALLTYPE *closeRegistry) (RegHandle); 00054 RegError (REGISTRY_CALLTYPE *destroyRegistry) (RegHandle, rtl_uString*); 00055 RegError (REGISTRY_CALLTYPE *loadKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*); 00056 RegError (REGISTRY_CALLTYPE *saveKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*); 00057 RegError (REGISTRY_CALLTYPE *mergeKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*, sal_Bool, sal_Bool); 00058 RegError (REGISTRY_CALLTYPE *dumpRegistry) (RegHandle, RegKeyHandle); 00059 void (REGISTRY_CALLTYPE *acquireKey) (RegKeyHandle); 00060 void (REGISTRY_CALLTYPE *releaseKey) (RegKeyHandle); 00061 sal_Bool (REGISTRY_CALLTYPE *isKeyReadOnly) (RegKeyHandle); 00062 RegError (REGISTRY_CALLTYPE *getKeyName) (RegKeyHandle, rtl_uString**); 00063 RegError (REGISTRY_CALLTYPE *createKey) (RegKeyHandle, rtl_uString*, RegKeyHandle*); 00064 RegError (REGISTRY_CALLTYPE *openKey) (RegKeyHandle, rtl_uString*, RegKeyHandle*); 00065 RegError (REGISTRY_CALLTYPE *openSubKeys) (RegKeyHandle, rtl_uString*, RegKeyHandle**, sal_uInt32*); 00066 RegError (REGISTRY_CALLTYPE *closeSubKeys) (RegKeyHandle*, sal_uInt32); 00067 RegError (REGISTRY_CALLTYPE *deleteKey) (RegKeyHandle, rtl_uString*); 00068 RegError (REGISTRY_CALLTYPE *closeKey) (RegKeyHandle); 00069 RegError (REGISTRY_CALLTYPE *setValue) (RegKeyHandle, rtl_uString*, RegValueType, RegValue, sal_uInt32); 00070 RegError (REGISTRY_CALLTYPE *setLongListValue) (RegKeyHandle, rtl_uString*, sal_Int32*, sal_uInt32); 00071 RegError (REGISTRY_CALLTYPE *setStringListValue) (RegKeyHandle, rtl_uString*, sal_Char**, sal_uInt32); 00072 RegError (REGISTRY_CALLTYPE *setUnicodeListValue)(RegKeyHandle, rtl_uString*, sal_Unicode**, sal_uInt32); 00073 RegError (REGISTRY_CALLTYPE *getValueInfo) (RegKeyHandle, rtl_uString*, RegValueType*, sal_uInt32*); 00074 RegError (REGISTRY_CALLTYPE *getValue) (RegKeyHandle, rtl_uString*, RegValue); 00075 RegError (REGISTRY_CALLTYPE *getLongListValue) (RegKeyHandle, rtl_uString*, sal_Int32**, sal_uInt32*); 00076 RegError (REGISTRY_CALLTYPE *getStringListValue) (RegKeyHandle, rtl_uString*, sal_Char***, sal_uInt32*); 00077 RegError (REGISTRY_CALLTYPE *getUnicodeListValue)(RegKeyHandle, rtl_uString*, sal_Unicode***, sal_uInt32*); 00078 RegError (REGISTRY_CALLTYPE *freeValueList) (RegValueType, RegValue, sal_uInt32); 00079 RegError (REGISTRY_CALLTYPE *createLink) (RegKeyHandle, rtl_uString*, rtl_uString*); 00080 RegError (REGISTRY_CALLTYPE *deleteLink) (RegKeyHandle, rtl_uString*); 00081 RegError (REGISTRY_CALLTYPE *getKeyType) (RegKeyHandle, rtl_uString*, RegKeyType*); 00082 RegError (REGISTRY_CALLTYPE *getLinkTarget) (RegKeyHandle, rtl_uString*, rtl_uString**); 00083 RegError (REGISTRY_CALLTYPE *getResolvedKeyName) (RegKeyHandle, rtl_uString*, sal_Bool, rtl_uString**); 00084 RegError (REGISTRY_CALLTYPE *getKeyNames) (RegKeyHandle, rtl_uString*, rtl_uString***, sal_uInt32*); 00085 RegError (REGISTRY_CALLTYPE *freeKeyNames) (rtl_uString**, sal_uInt32); 00086 }; 00087 00090 REG_DLLPUBLIC Registry_Api* REGISTRY_CALLTYPE initRegistry_Api(void); 00091 00092 #ifdef __cplusplus 00093 } 00094 #endif 00095 00096 00097 class RegistryKey; 00098 00099 //----------------------------------------------------------------------------- 00100 00105 class Registry 00106 { 00107 public: 00110 inline Registry(); 00111 00113 inline Registry(const Registry& toCopy); 00114 00116 inline ~Registry(); 00117 00119 inline Registry& operator = (const Registry& toAssign); 00120 00122 inline sal_Bool isValid() const; 00123 00128 inline sal_Bool isReadOnly() const; 00129 00135 inline RegError openRootKey(RegistryKey& rRootKey); 00136 00138 inline ::rtl::OUString getName(); 00139 00145 inline RegError create(const ::rtl::OUString& registryName); 00146 00154 inline RegError open(const ::rtl::OUString& registryName, 00155 RegAccessMode accessMode); 00156 00158 inline RegError close(); 00159 00166 inline RegError destroy(const ::rtl::OUString& registryName); 00167 00179 inline RegError loadKey(RegistryKey& rKey, 00180 const ::rtl::OUString& keyName, 00181 const ::rtl::OUString& regFileName); 00182 00194 inline RegError saveKey(RegistryKey& rKey, 00195 const ::rtl::OUString& keyName, 00196 const ::rtl::OUString& regFileName); 00197 00213 inline RegError mergeKey(RegistryKey& rKey, 00214 const ::rtl::OUString& keyName, 00215 const ::rtl::OUString& regFileName, 00216 sal_Bool bWarnings = sal_False, 00217 sal_Bool bReport = sal_False); 00218 00226 inline RegError dumpRegistry(RegistryKey& rKey); 00227 00228 friend class RegistryKey; 00229 friend class RegistryKeyArray; 00230 friend class RegistryKeyNames; 00231 00233 const Registry_Api* getApi() { return m_pApi; } 00234 protected: 00235 00237 const Registry_Api* m_pApi; 00239 RegHandle m_hImpl; 00240 }; 00241 00242 00243 //----------------------------------------------------------------------------- 00244 00249 class RegistryKeyArray 00250 { 00251 public: 00253 inline RegistryKeyArray(); 00254 00256 inline ~RegistryKeyArray(); 00257 00259 inline RegistryKey getElement(sal_uInt32 index); 00260 00262 inline sal_uInt32 getLength(); 00263 00264 friend class RegistryKey; 00265 protected: 00272 inline void setKeyHandles(Registry& registry, RegKeyHandle* phKeys, sal_uInt32 length); 00274 inline RegError closeKeyHandles(); 00275 00277 sal_uInt32 m_length; 00279 RegKeyHandle* m_phKeys; 00281 Registry m_registry; 00282 }; 00283 00284 00289 class RegistryKeyNames 00290 { 00291 public: 00293 inline RegistryKeyNames(); 00294 00296 inline ~RegistryKeyNames(); 00297 00299 inline ::rtl::OUString getElement(sal_uInt32 index); 00300 00302 inline sal_uInt32 getLength(); 00303 00304 friend class RegistryKey; 00305 protected: 00312 inline void setKeyNames(Registry& registry, rtl_uString** pKeyNames, sal_uInt32 length); 00314 inline RegError freeKeyNames(); 00315 00317 sal_uInt32 m_length; 00319 rtl_uString** m_pKeyNames; 00321 Registry m_registry; 00322 }; 00323 00324 //----------------------------------------------------------------------------- 00325 00330 template<class ValueType> 00331 class RegistryValueList 00332 { 00333 public: 00335 RegistryValueList() 00336 : m_length(0) 00337 , m_pValueList(NULL) 00338 , m_valueType(RG_VALUETYPE_NOT_DEFINED) 00339 {} 00340 00342 ~RegistryValueList() 00343 { 00344 if (m_pValueList) 00345 { 00346 m_registry.getApi()->freeValueList(m_valueType, m_pValueList, m_length); 00347 } 00348 } 00349 00351 ValueType getElement(sal_uInt32 index) 00352 { 00353 if (m_registry.isValid() && index < m_length) 00354 { 00355 return m_pValueList[index]; 00356 } else 00357 { 00358 return 0; 00359 } 00360 } 00361 00363 sal_uInt32 getLength() 00364 { 00365 return m_length; 00366 } 00367 00368 friend class RegistryKey; 00369 protected: 00377 void setValueList(Registry& registry, RegValueType valueType, 00378 ValueType* pValueList, sal_uInt32 length) 00379 { 00380 m_length = length; 00381 m_pValueList = pValueList; 00382 m_valueType = valueType; 00383 m_registry = registry; 00384 } 00385 00387 sal_uInt32 m_length; 00389 ValueType* m_pValueList; 00391 RegValueType m_valueType; 00395 Registry m_registry; 00396 }; 00397 00398 //----------------------------------------------------------------------------- 00399 00404 class RegistryKey 00405 { 00406 public: 00408 inline RegistryKey(); 00409 00411 inline RegistryKey(const RegistryKey& toCopy); 00412 00414 inline ~RegistryKey(); 00415 00417 inline RegistryKey& operator = (const RegistryKey& toAssign); 00418 00420 inline sal_Bool isValid() const; 00421 00426 inline sal_Bool isReadOnly() const; 00427 00429 inline ::rtl::OUString getName(); 00430 00438 inline RegError createKey(const ::rtl::OUString& keyName, 00439 RegistryKey& rNewKey); 00440 00448 inline RegError openKey(const ::rtl::OUString& keyName, 00449 RegistryKey& rOpenKey); 00450 00458 inline RegError openSubKeys(const ::rtl::OUString& keyName, 00459 RegistryKeyArray& rSubKeys); 00460 00468 inline RegError getKeyNames(const ::rtl::OUString& keyName, 00469 RegistryKeyNames& rSubKeyNames); 00470 00476 inline RegError closeSubKeys(RegistryKeyArray& rSubKeys); 00477 00483 inline RegError deleteKey(const ::rtl::OUString& keyName); 00484 00486 inline RegError closeKey(); 00487 00489 inline void releaseKey(); 00490 00501 inline RegError setValue(const ::rtl::OUString& keyName, 00502 RegValueType valueType, 00503 RegValue pValue, 00504 sal_uInt32 valueSize); 00505 00515 inline RegError setLongListValue(const ::rtl::OUString& keyName, 00516 sal_Int32* pValueList, 00517 sal_uInt32 len); 00518 00528 inline RegError setStringListValue(const ::rtl::OUString& keyName, 00529 sal_Char** pValueList, 00530 sal_uInt32 len); 00531 00541 inline RegError setUnicodeListValue(const ::rtl::OUString& keyName, 00542 sal_Unicode** pValueList, 00543 sal_uInt32 len); 00544 00554 inline RegError getValueInfo(const ::rtl::OUString& keyName, 00555 RegValueType* pValueType, 00556 sal_uInt32* pValueSize); 00557 00566 inline RegError getValue(const ::rtl::OUString& keyName, 00567 RegValue pValue); 00568 00577 inline RegError getLongListValue(const ::rtl::OUString& keyName, 00578 RegistryValueList<sal_Int32>& rValueList); 00579 00588 inline RegError getStringListValue(const ::rtl::OUString& keyName, 00589 RegistryValueList<sal_Char*>& rValueList); 00590 00599 inline RegError getUnicodeListValue(const ::rtl::OUString& keyName, 00600 RegistryValueList<sal_Unicode*>& rValueList); 00601 00608 inline RegError createLink(const ::rtl::OUString& linkName, 00609 const ::rtl::OUString& linkTarget); 00610 00617 inline RegError deleteLink(const ::rtl::OUString& linkName); 00618 00625 inline RegError getKeyType(const ::rtl::OUString& name, 00626 RegKeyType* pKeyType) const; 00627 00634 inline RegError getLinkTarget(const ::rtl::OUString& linkName, 00635 ::rtl::OUString& rLinkTarget) const; 00636 00644 inline RegError getResolvedKeyName(const ::rtl::OUString& keyName, 00645 sal_Bool firstLinkOnly, 00646 ::rtl::OUString& rResolvedName) const; 00647 00649 inline ::rtl::OUString getRegistryName(); 00650 00652 Registry getRegistry() const { return m_registry; } 00653 00654 friend class Registry; 00655 public: 00657 00662 inline RegistryKey(Registry& registry, 00663 RegKeyHandle hKey); 00664 00667 RegKeyHandle getKeyHandle() const { return m_hImpl; } 00668 00669 protected: 00672 inline void setRegistry(Registry& registry); 00673 00675 00677 Registry m_registry; 00679 RegKeyHandle m_hImpl; 00680 }; 00681 00682 00683 //----------------------------------------------------------------------------- 00684 00685 inline RegistryKeyArray::RegistryKeyArray() 00686 : m_length(0) 00687 , m_phKeys(NULL) 00688 { 00689 } 00690 00691 inline RegistryKeyArray::~RegistryKeyArray() 00692 { 00693 if (m_phKeys) 00694 m_registry.m_pApi->closeSubKeys(m_phKeys, m_length); 00695 } 00696 00697 inline RegistryKey RegistryKeyArray::getElement(sal_uInt32 index) 00698 { 00699 if (m_registry.isValid() && index < m_length) 00700 return RegistryKey(m_registry, m_phKeys[index]); 00701 else 00702 return RegistryKey(); 00703 } 00704 00705 inline sal_uInt32 RegistryKeyArray::getLength() 00706 { 00707 return m_length; 00708 } 00709 00710 inline void RegistryKeyArray::setKeyHandles(Registry& registry, 00711 RegKeyHandle* phKeys, 00712 sal_uInt32 length) 00713 { 00714 m_phKeys = phKeys; 00715 m_length = length; 00716 m_registry = registry; 00717 } 00718 00719 inline RegError RegistryKeyArray::closeKeyHandles() 00720 { 00721 if (m_registry.isValid() && m_phKeys) 00722 { 00723 RegError ret; 00724 ret = m_registry.m_pApi->closeSubKeys(m_phKeys, m_length); 00725 m_registry = Registry(); 00726 m_length = 0; 00727 m_phKeys = NULL; 00728 return ret; 00729 } else 00730 return(REG_INVALID_KEY); 00731 } 00732 00733 //----------------------------------------------------------------------------- 00734 00735 inline RegistryKeyNames::RegistryKeyNames() 00736 : m_length(0) 00737 , m_pKeyNames(NULL) 00738 { 00739 } 00740 00741 inline RegistryKeyNames::~RegistryKeyNames() 00742 { 00743 if (m_pKeyNames) 00744 m_registry.m_pApi->freeKeyNames(m_pKeyNames, m_length); 00745 } 00746 00747 inline ::rtl::OUString RegistryKeyNames::getElement(sal_uInt32 index) 00748 { 00749 00750 if (m_pKeyNames && index < m_length) 00751 return m_pKeyNames[index]; 00752 else 00753 return ::rtl::OUString(); 00754 } 00755 00756 inline sal_uInt32 RegistryKeyNames::getLength() 00757 { 00758 return m_length; 00759 } 00760 00761 inline void RegistryKeyNames::setKeyNames(Registry& registry, 00762 rtl_uString** pKeyNames, 00763 sal_uInt32 length) 00764 { 00765 m_pKeyNames = pKeyNames; 00766 m_length = length; 00767 m_registry = registry; 00768 } 00769 00770 inline RegError RegistryKeyNames::freeKeyNames() 00771 { 00772 if (m_registry.isValid() && m_pKeyNames) 00773 { 00774 RegError ret = REG_NO_ERROR; 00775 ret = m_registry.m_pApi->freeKeyNames(m_pKeyNames, m_length); 00776 m_registry = Registry(); 00777 m_length = 0; 00778 m_pKeyNames = NULL; 00779 return ret; 00780 } else 00781 return REG_INVALID_KEY; 00782 } 00783 00784 //----------------------------------------------------------------------------- 00785 00786 inline RegistryKey::RegistryKey() 00787 : m_hImpl(NULL) 00788 { } 00789 00791 inline RegistryKey::RegistryKey(Registry& registry, RegKeyHandle hKey) 00792 : m_registry(registry) 00793 , m_hImpl(hKey) 00794 { 00795 if (m_hImpl) 00796 m_registry.m_pApi->acquireKey(m_hImpl); 00797 } 00799 00800 inline RegistryKey::RegistryKey(const RegistryKey& toCopy) 00801 : m_registry(toCopy.m_registry) 00802 , m_hImpl(toCopy.m_hImpl) 00803 { 00804 if (m_hImpl) 00805 m_registry.m_pApi->acquireKey(m_hImpl); 00806 } 00807 00809 inline void RegistryKey::setRegistry(Registry& registry) 00810 { 00811 m_registry = registry; 00812 } 00814 00815 inline RegistryKey::~RegistryKey() 00816 { 00817 if (m_hImpl) 00818 m_registry.m_pApi->releaseKey(m_hImpl); 00819 } 00820 00821 inline RegistryKey& RegistryKey::operator = (const RegistryKey& toAssign) 00822 { 00823 m_registry = toAssign.m_registry; 00824 00825 if (toAssign.m_hImpl) 00826 m_registry.m_pApi->acquireKey(toAssign.m_hImpl); 00827 if (m_hImpl) 00828 m_registry.m_pApi->releaseKey(m_hImpl); 00829 m_hImpl = toAssign.m_hImpl; 00830 00831 return *this; 00832 } 00833 00834 inline sal_Bool RegistryKey::isValid() const 00835 { return (m_hImpl != NULL); } 00836 00837 inline sal_Bool RegistryKey::isReadOnly() const 00838 { 00839 if (m_registry.isValid()) 00840 return (m_registry.m_pApi)->isKeyReadOnly(m_hImpl); 00841 else 00842 return sal_False; 00843 } 00844 00845 inline ::rtl::OUString RegistryKey::getName() 00846 { 00847 ::rtl::OUString sRet; 00848 if (m_registry.isValid()) 00849 m_registry.m_pApi->getKeyName(m_hImpl, &sRet.pData); 00850 return sRet; 00851 } 00852 00853 inline RegError RegistryKey::createKey(const ::rtl::OUString& keyName, 00854 RegistryKey& rNewKey) 00855 { 00856 if (rNewKey.isValid()) rNewKey.closeKey(); 00857 if (m_registry.isValid()) 00858 { 00859 RegError ret = m_registry.m_pApi->createKey(m_hImpl, keyName.pData, &rNewKey.m_hImpl); 00860 if (!ret) rNewKey.setRegistry(m_registry); 00861 return ret; 00862 } else 00863 return REG_INVALID_KEY; 00864 } 00865 00866 inline RegError RegistryKey::openKey(const ::rtl::OUString& keyName, 00867 RegistryKey& rOpenKey) 00868 { 00869 if (rOpenKey.isValid()) rOpenKey.closeKey(); 00870 if (m_registry.isValid()) 00871 { 00872 RegError ret = m_registry.m_pApi->openKey(m_hImpl, keyName.pData, 00873 &rOpenKey.m_hImpl); 00874 if (!ret) rOpenKey.setRegistry(m_registry); 00875 return ret; 00876 } else 00877 return REG_INVALID_KEY; 00878 } 00879 00880 inline RegError RegistryKey::openSubKeys(const ::rtl::OUString& keyName, 00881 RegistryKeyArray& rSubKeys) 00882 { 00883 if (m_registry.isValid()) 00884 { 00885 RegError ret = REG_NO_ERROR; 00886 RegKeyHandle* pSubKeys; 00887 sal_uInt32 nSubKeys; 00888 ret = m_registry.m_pApi->openSubKeys(m_hImpl, keyName.pData, 00889 &pSubKeys, &nSubKeys); 00890 if ( ret ) 00891 { 00892 return ret; 00893 } else 00894 { 00895 rSubKeys.setKeyHandles(m_registry, pSubKeys, nSubKeys); 00896 return ret; 00897 } 00898 } else 00899 return REG_INVALID_KEY; 00900 } 00901 00902 inline RegError RegistryKey::getKeyNames(const ::rtl::OUString& keyName, 00903 RegistryKeyNames& rSubKeyNames) 00904 { 00905 if (m_registry.isValid()) 00906 { 00907 RegError ret = REG_NO_ERROR; 00908 rtl_uString** pSubKeyNames; 00909 sal_uInt32 nSubKeys; 00910 ret = m_registry.m_pApi->getKeyNames(m_hImpl, keyName.pData, 00911 &pSubKeyNames, &nSubKeys); 00912 if ( ret ) 00913 { 00914 return ret; 00915 } else 00916 { 00917 rSubKeyNames.setKeyNames(m_registry, pSubKeyNames, nSubKeys); 00918 return ret; 00919 } 00920 } else 00921 return REG_INVALID_KEY; 00922 } 00923 00924 inline RegError RegistryKey::closeSubKeys(RegistryKeyArray& rSubKeys) 00925 { 00926 if (m_registry.isValid()) 00927 return rSubKeys.closeKeyHandles(); 00928 else 00929 return REG_INVALID_KEY; 00930 } 00931 00932 inline RegError RegistryKey::deleteKey(const ::rtl::OUString& keyName) 00933 { 00934 if (m_registry.isValid()) 00935 return m_registry.m_pApi->deleteKey(m_hImpl, keyName.pData); 00936 else 00937 return REG_INVALID_KEY; 00938 } 00939 00940 inline RegError RegistryKey::closeKey() 00941 { 00942 if (m_registry.isValid()) 00943 { 00944 RegError ret = m_registry.m_pApi->closeKey(m_hImpl); 00945 if (!ret) 00946 { 00947 m_hImpl = NULL; 00948 m_registry = Registry(); 00949 } 00950 return ret; 00951 } else 00952 return REG_INVALID_KEY; 00953 } 00954 00955 inline void RegistryKey::releaseKey() 00956 { 00957 if (m_registry.isValid() && (m_hImpl != 0)) 00958 { 00959 m_registry.m_pApi->releaseKey(m_hImpl), m_hImpl = 0; 00960 } 00961 } 00962 00963 inline RegError RegistryKey::setValue(const ::rtl::OUString& keyName, 00964 RegValueType valueType, 00965 RegValue pValue, 00966 sal_uInt32 valueSize) 00967 { 00968 if (m_registry.isValid()) 00969 return m_registry.m_pApi->setValue(m_hImpl, keyName.pData, valueType, 00970 pValue, valueSize); 00971 else 00972 return REG_INVALID_KEY; 00973 } 00974 00975 inline RegError RegistryKey::setLongListValue(const ::rtl::OUString& keyName, 00976 sal_Int32* pValueList, 00977 sal_uInt32 len) 00978 { 00979 if (m_registry.isValid()) 00980 return m_registry.m_pApi->setLongListValue(m_hImpl, keyName.pData, 00981 pValueList, len); 00982 else 00983 return REG_INVALID_KEY; 00984 } 00985 00986 inline RegError RegistryKey::setStringListValue(const ::rtl::OUString& keyName, 00987 sal_Char** pValueList, 00988 sal_uInt32 len) 00989 { 00990 if (m_registry.isValid()) 00991 return m_registry.m_pApi->setStringListValue(m_hImpl, keyName.pData, 00992 pValueList, len); 00993 else 00994 return REG_INVALID_KEY; 00995 } 00996 00997 inline RegError RegistryKey::setUnicodeListValue(const ::rtl::OUString& keyName, 00998 sal_Unicode** pValueList, 00999 sal_uInt32 len) 01000 { 01001 if (m_registry.isValid()) 01002 return m_registry.m_pApi->setUnicodeListValue(m_hImpl, keyName.pData, 01003 pValueList, len); 01004 else 01005 return REG_INVALID_KEY; 01006 } 01007 01008 inline RegError RegistryKey::getValueInfo(const ::rtl::OUString& keyName, 01009 RegValueType* pValueType, 01010 sal_uInt32* pValueSize) 01011 { 01012 if (m_registry.isValid()) 01013 return m_registry.m_pApi->getValueInfo(m_hImpl, keyName.pData, pValueType, pValueSize); 01014 else 01015 return REG_INVALID_KEY; 01016 } 01017 01018 inline RegError RegistryKey::getValue(const ::rtl::OUString& keyName, 01019 RegValue pValue) 01020 { 01021 if (m_registry.isValid()) 01022 return m_registry.m_pApi->getValue(m_hImpl, keyName.pData, pValue); 01023 else 01024 return REG_INVALID_KEY; 01025 } 01026 01027 inline RegError RegistryKey::getLongListValue(const ::rtl::OUString& keyName, 01028 RegistryValueList<sal_Int32>& rValueList) 01029 { 01030 if (m_registry.isValid()) 01031 { 01032 RegError ret = REG_NO_ERROR; 01033 sal_Int32* pValueList; 01034 sal_uInt32 length; 01035 ret = m_registry.m_pApi->getLongListValue(m_hImpl, keyName.pData, 01036 &pValueList, &length); 01037 if ( ret ) 01038 { 01039 return ret; 01040 } else 01041 { 01042 rValueList.setValueList(m_registry, RG_VALUETYPE_LONGLIST, 01043 pValueList, length); 01044 return ret; 01045 } 01046 } else 01047 return REG_INVALID_KEY; 01048 } 01049 01050 inline RegError RegistryKey::getStringListValue(const ::rtl::OUString& keyName, 01051 RegistryValueList<sal_Char*>& rValueList) 01052 { 01053 if (m_registry.isValid()) 01054 { 01055 RegError ret = REG_NO_ERROR; 01056 sal_Char** pValueList; 01057 sal_uInt32 length; 01058 ret = m_registry.m_pApi->getStringListValue(m_hImpl, keyName.pData, 01059 &pValueList, &length); 01060 if ( ret ) 01061 { 01062 return ret; 01063 } else 01064 { 01065 rValueList.setValueList(m_registry, RG_VALUETYPE_STRINGLIST, 01066 pValueList, length); 01067 return ret; 01068 } 01069 } else 01070 return REG_INVALID_KEY; 01071 } 01072 01073 inline RegError RegistryKey::getUnicodeListValue(const ::rtl::OUString& keyName, 01074 RegistryValueList<sal_Unicode*>& rValueList) 01075 { 01076 if (m_registry.isValid()) 01077 { 01078 RegError ret = REG_NO_ERROR; 01079 sal_Unicode** pValueList; 01080 sal_uInt32 length; 01081 ret = m_registry.m_pApi->getUnicodeListValue(m_hImpl, keyName.pData, 01082 &pValueList, &length); 01083 if ( ret ) 01084 { 01085 return ret; 01086 } else 01087 { 01088 rValueList.setValueList(m_registry, RG_VALUETYPE_UNICODELIST, 01089 pValueList, length); 01090 return ret; 01091 } 01092 } else 01093 return REG_INVALID_KEY; 01094 } 01095 01096 inline RegError RegistryKey::createLink(const ::rtl::OUString& linkName, 01097 const ::rtl::OUString& linkTarget) 01098 { 01099 if (m_registry.isValid()) 01100 return m_registry.m_pApi->createLink(m_hImpl, linkName.pData, linkTarget.pData); 01101 else 01102 return REG_INVALID_KEY; 01103 } 01104 01105 inline RegError RegistryKey::deleteLink(const ::rtl::OUString& linkName) 01106 { 01107 if (m_registry.isValid()) 01108 return m_registry.m_pApi->deleteLink(m_hImpl, linkName.pData); 01109 else 01110 return REG_INVALID_KEY; 01111 } 01112 01113 inline RegError RegistryKey::getKeyType(const ::rtl::OUString& keyName, 01114 RegKeyType* pKeyType) const 01115 { 01116 if (m_registry.isValid()) 01117 return m_registry.m_pApi->getKeyType(m_hImpl, keyName.pData, pKeyType); 01118 else 01119 return REG_INVALID_KEY; 01120 } 01121 01122 inline RegError RegistryKey::getLinkTarget(const ::rtl::OUString& linkName, 01123 ::rtl::OUString& rLinkTarget) const 01124 { 01125 if (m_registry.isValid()) 01126 { 01127 return m_registry.m_pApi->getLinkTarget(m_hImpl, 01128 linkName.pData, 01129 &rLinkTarget.pData); 01130 } else 01131 return REG_INVALID_KEY; 01132 } 01133 01134 01135 inline RegError RegistryKey::getResolvedKeyName(const ::rtl::OUString& keyName, 01136 sal_Bool firstLinkOnly, 01137 ::rtl::OUString& rResolvedName) const 01138 { 01139 if (m_registry.isValid()) 01140 return m_registry.m_pApi->getResolvedKeyName(m_hImpl, 01141 keyName.pData, 01142 firstLinkOnly, 01143 &rResolvedName.pData); 01144 else 01145 return REG_INVALID_KEY; 01146 } 01147 01148 inline ::rtl::OUString RegistryKey::getRegistryName() 01149 { 01150 if (m_registry.isValid()) 01151 { 01152 return m_registry.getName(); 01153 } else 01154 return ::rtl::OUString(); 01155 } 01156 01157 //----------------------------------------------------------------------------- 01158 01159 inline Registry::Registry() 01160 : m_pApi(initRegistry_Api()) 01161 , m_hImpl(NULL) 01162 { } 01163 01164 inline Registry::Registry(const Registry& toCopy) 01165 : m_pApi(toCopy.m_pApi) 01166 , m_hImpl(toCopy.m_hImpl) 01167 { 01168 if (m_hImpl) 01169 m_pApi->acquire(m_hImpl); 01170 } 01171 01172 01173 inline Registry::~Registry() 01174 { 01175 if (m_hImpl) 01176 m_pApi->release(m_hImpl); 01177 } 01178 01179 inline Registry& Registry::operator = (const Registry& toAssign) 01180 { 01181 if (toAssign.m_hImpl) 01182 toAssign.m_pApi->acquire(toAssign.m_hImpl); 01183 if (m_hImpl) 01184 m_pApi->release(m_hImpl); 01185 01186 m_pApi = toAssign.m_pApi; 01187 m_hImpl = toAssign.m_hImpl; 01188 01189 return *this; 01190 } 01191 01192 inline sal_Bool Registry::isValid() const 01193 { return ( m_hImpl != NULL ); } 01194 01195 inline sal_Bool Registry::isReadOnly() const 01196 { return m_pApi->isReadOnly(m_hImpl); } 01197 01198 inline RegError Registry::openRootKey(RegistryKey& rRootKey) 01199 { 01200 rRootKey.setRegistry(*this); 01201 return m_pApi->openRootKey(m_hImpl, &rRootKey.m_hImpl); 01202 } 01203 01204 inline ::rtl::OUString Registry::getName() 01205 { 01206 ::rtl::OUString sRet; 01207 m_pApi->getName(m_hImpl, &sRet.pData); 01208 return sRet; 01209 } 01210 01211 inline RegError Registry::create(const ::rtl::OUString& registryName) 01212 { 01213 if (m_hImpl) 01214 m_pApi->release(m_hImpl); 01215 return m_pApi->createRegistry(registryName.pData, &m_hImpl); 01216 } 01217 01218 inline RegError Registry::open(const ::rtl::OUString& registryName, 01219 RegAccessMode accessMode) 01220 { 01221 if (m_hImpl) 01222 m_pApi->release(m_hImpl); 01223 return m_pApi->openRegistry(registryName.pData, &m_hImpl, accessMode); 01224 } 01225 01226 inline RegError Registry::close() 01227 { 01228 RegError ret = m_pApi->closeRegistry(m_hImpl); 01229 if (!ret) 01230 m_hImpl = NULL; 01231 return ret; 01232 } 01233 01234 inline RegError Registry::destroy(const ::rtl::OUString& registryName) 01235 { 01236 RegError ret = m_pApi->destroyRegistry(m_hImpl, registryName.pData); 01237 if ( !ret && registryName.isEmpty() ) 01238 m_hImpl = NULL; 01239 return ret; 01240 } 01241 01242 inline RegError Registry::loadKey(RegistryKey& rKey, 01243 const ::rtl::OUString& keyName, 01244 const ::rtl::OUString& regFileName) 01245 { return m_pApi->loadKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData); } 01246 01247 inline RegError Registry::saveKey(RegistryKey& rKey, 01248 const ::rtl::OUString& keyName, 01249 const ::rtl::OUString& regFileName) 01250 { return m_pApi->saveKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData); } 01251 01252 inline RegError Registry::mergeKey(RegistryKey& rKey, 01253 const ::rtl::OUString& keyName, 01254 const ::rtl::OUString& regFileName, 01255 sal_Bool bWarnings, 01256 sal_Bool bReport) 01257 { return m_pApi->mergeKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData, bWarnings, bReport); } 01258 01259 inline RegError Registry::dumpRegistry(RegistryKey& rKey) 01260 { return m_pApi->dumpRegistry(m_hImpl, rKey.m_hImpl); } 01261 01262 01263 #endif 01264 01265 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */