UDK 3.2.7 C/C++ API Reference
registry/registry.hxx
Go to the documentation of this file.
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: */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines