My Project
UDK 3.2.7 C/C++ API Reference
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
registry.hxx
Go to the documentation of this file.
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3  * This file is part of the LibreOffice project.
4  *
5  * This Source Code Form is subject to the terms of the Mozilla Public
6  * License, v. 2.0. If a copy of the MPL was not distributed with this
7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8  *
9  * This file incorporates work covered by the following license notice:
10  *
11  * Licensed to the Apache Software Foundation (ASF) under one or more
12  * contributor license agreements. See the NOTICE file distributed
13  * with this work for additional information regarding copyright
14  * ownership. The ASF licenses this file to you under the Apache
15  * License, Version 2.0 (the "License"); you may not use this file
16  * except in compliance with the License. You may obtain a copy of
17  * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18  */
19 
20 #ifndef _REGISTRY_REGISTRY_HXX_
21 #define _REGISTRY_REGISTRY_HXX_
22 
23 #include <registry/regdllapi.h>
24 #include <registry/regtype.h>
25 #include <rtl/ustring.hxx>
26 
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30 
36 {
37  void (REGISTRY_CALLTYPE *acquire) (RegHandle);
38  void (REGISTRY_CALLTYPE *release) (RegHandle);
39  sal_Bool (REGISTRY_CALLTYPE *isReadOnly) (RegHandle);
41  RegError (REGISTRY_CALLTYPE *getName) (RegHandle, rtl_uString**);
42  RegError (REGISTRY_CALLTYPE *createRegistry) (rtl_uString*, RegHandle*);
43  RegError (REGISTRY_CALLTYPE *openRegistry) (rtl_uString*, RegHandle*, RegAccessMode);
44  RegError (REGISTRY_CALLTYPE *closeRegistry) (RegHandle);
45  RegError (REGISTRY_CALLTYPE *destroyRegistry) (RegHandle, rtl_uString*);
46  RegError (REGISTRY_CALLTYPE *loadKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*);
47  RegError (REGISTRY_CALLTYPE *saveKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*);
48  RegError (REGISTRY_CALLTYPE *mergeKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*, sal_Bool, sal_Bool);
50  void (REGISTRY_CALLTYPE *acquireKey) (RegKeyHandle);
51  void (REGISTRY_CALLTYPE *releaseKey) (RegKeyHandle);
52  sal_Bool (REGISTRY_CALLTYPE *isKeyReadOnly) (RegKeyHandle);
53  RegError (REGISTRY_CALLTYPE *getKeyName) (RegKeyHandle, rtl_uString**);
54  RegError (REGISTRY_CALLTYPE *createKey) (RegKeyHandle, rtl_uString*, RegKeyHandle*);
55  RegError (REGISTRY_CALLTYPE *openKey) (RegKeyHandle, rtl_uString*, RegKeyHandle*);
56  RegError (REGISTRY_CALLTYPE *openSubKeys) (RegKeyHandle, rtl_uString*, RegKeyHandle**, sal_uInt32*);
58  RegError (REGISTRY_CALLTYPE *deleteKey) (RegKeyHandle, rtl_uString*);
61  RegError (REGISTRY_CALLTYPE *setLongListValue) (RegKeyHandle, rtl_uString*, sal_Int32*, sal_uInt32);
62  RegError (REGISTRY_CALLTYPE *setStringListValue) (RegKeyHandle, rtl_uString*, sal_Char**, sal_uInt32);
63  RegError (REGISTRY_CALLTYPE *setUnicodeListValue)(RegKeyHandle, rtl_uString*, sal_Unicode**, sal_uInt32);
64  RegError (REGISTRY_CALLTYPE *getValueInfo) (RegKeyHandle, rtl_uString*, RegValueType*, sal_uInt32*);
65  RegError (REGISTRY_CALLTYPE *getValue) (RegKeyHandle, rtl_uString*, RegValue);
66  RegError (REGISTRY_CALLTYPE *getLongListValue) (RegKeyHandle, rtl_uString*, sal_Int32**, sal_uInt32*);
67  RegError (REGISTRY_CALLTYPE *getStringListValue) (RegKeyHandle, rtl_uString*, sal_Char***, sal_uInt32*);
68  RegError (REGISTRY_CALLTYPE *getUnicodeListValue)(RegKeyHandle, rtl_uString*, sal_Unicode***, sal_uInt32*);
70  RegError (REGISTRY_CALLTYPE *createLink) (RegKeyHandle, rtl_uString*, rtl_uString*);
71  RegError (REGISTRY_CALLTYPE *deleteLink) (RegKeyHandle, rtl_uString*);
72  RegError (REGISTRY_CALLTYPE *getKeyType) (RegKeyHandle, rtl_uString*, RegKeyType*);
73  RegError (REGISTRY_CALLTYPE *getLinkTarget) (RegKeyHandle, rtl_uString*, rtl_uString**);
74  RegError (REGISTRY_CALLTYPE *getResolvedKeyName) (RegKeyHandle, rtl_uString*, sal_Bool, rtl_uString**);
75  RegError (REGISTRY_CALLTYPE *getKeyNames) (RegKeyHandle, rtl_uString*, rtl_uString***, sal_uInt32*);
76  RegError (REGISTRY_CALLTYPE *freeKeyNames) (rtl_uString**, sal_uInt32);
77 };
78 
82 
83 #ifdef __cplusplus
84 }
85 #endif
86 
87 
88 class RegistryKey;
89 
90 //-----------------------------------------------------------------------------
91 
96 class Registry
97 {
98 public:
101  inline Registry();
102 
104  inline Registry(const Registry& toCopy);
105 
107  inline ~Registry();
108 
110  inline Registry& operator = (const Registry& toAssign);
111 
113  inline sal_Bool isValid() const;
114 
119  inline sal_Bool isReadOnly() const;
120 
126  inline RegError openRootKey(RegistryKey& rRootKey);
127 
129  inline ::rtl::OUString getName();
130 
136  inline RegError create(const ::rtl::OUString& registryName);
137 
145  inline RegError open(const ::rtl::OUString& registryName,
146  RegAccessMode accessMode);
147 
149  inline RegError close();
150 
157  inline RegError destroy(const ::rtl::OUString& registryName);
158 
170  inline RegError loadKey(RegistryKey& rKey,
171  const ::rtl::OUString& keyName,
172  const ::rtl::OUString& regFileName);
173 
185  inline RegError saveKey(RegistryKey& rKey,
186  const ::rtl::OUString& keyName,
187  const ::rtl::OUString& regFileName);
188 
204  inline RegError mergeKey(RegistryKey& rKey,
205  const ::rtl::OUString& keyName,
206  const ::rtl::OUString& regFileName,
207  sal_Bool bWarnings = sal_False,
208  sal_Bool bReport = sal_False);
209 
217  inline RegError dumpRegistry(RegistryKey& rKey);
218 
219  friend class RegistryKey;
220  friend class RegistryKeyArray;
221  friend class RegistryKeyNames;
222 
224  const Registry_Api* getApi() { return m_pApi; }
225 protected:
226 
231 };
232 
233 
234 //-----------------------------------------------------------------------------
235 
241 {
242 public:
244  inline RegistryKeyArray();
245 
247  inline ~RegistryKeyArray();
248 
250  inline RegistryKey getElement(sal_uInt32 index);
251 
253  inline sal_uInt32 getLength();
254 
255  friend class RegistryKey;
256 protected:
263  inline void setKeyHandles(Registry& registry, RegKeyHandle* phKeys, sal_uInt32 length);
265  inline RegError closeKeyHandles();
266 
268  sal_uInt32 m_length;
273 };
274 
275 
281 {
282 public:
284  inline RegistryKeyNames();
285 
287  inline ~RegistryKeyNames();
288 
290  inline ::rtl::OUString getElement(sal_uInt32 index);
291 
293  inline sal_uInt32 getLength();
294 
295  friend class RegistryKey;
296 protected:
303  inline void setKeyNames(Registry& registry, rtl_uString** pKeyNames, sal_uInt32 length);
305  inline RegError freeKeyNames();
306 
308  sal_uInt32 m_length;
310  rtl_uString** m_pKeyNames;
313 };
314 
315 //-----------------------------------------------------------------------------
316 
321 template<class ValueType>
323 {
324 public:
327  : m_length(0)
328  , m_pValueList(NULL)
330  {}
331 
334  {
335  if (m_pValueList)
336  {
337  m_registry.getApi()->freeValueList(m_valueType, m_pValueList, m_length);
338  }
339  }
340 
342  ValueType getElement(sal_uInt32 index)
343  {
344  if (m_registry.isValid() && index < m_length)
345  {
346  return m_pValueList[index];
347  } else
348  {
349  return 0;
350  }
351  }
352 
354  sal_uInt32 getLength()
355  {
356  return m_length;
357  }
358 
359  friend class RegistryKey;
360 protected:
368  void setValueList(Registry& registry, RegValueType valueType,
369  ValueType* pValueList, sal_uInt32 length)
370  {
371  m_length = length;
372  m_pValueList = pValueList;
373  m_valueType = valueType;
374  m_registry = registry;
375  }
376 
378  sal_uInt32 m_length;
380  ValueType* m_pValueList;
387 };
388 
389 //-----------------------------------------------------------------------------
390 
396 {
397 public:
399  inline RegistryKey();
400 
402  inline RegistryKey(const RegistryKey& toCopy);
403 
405  inline ~RegistryKey();
406 
408  inline RegistryKey& operator = (const RegistryKey& toAssign);
409 
411  inline sal_Bool isValid() const;
412 
417  inline sal_Bool isReadOnly() const;
418 
420  inline ::rtl::OUString getName();
421 
429  inline RegError createKey(const ::rtl::OUString& keyName,
430  RegistryKey& rNewKey);
431 
439  inline RegError openKey(const ::rtl::OUString& keyName,
440  RegistryKey& rOpenKey);
441 
449  inline RegError openSubKeys(const ::rtl::OUString& keyName,
450  RegistryKeyArray& rSubKeys);
451 
459  inline RegError getKeyNames(const ::rtl::OUString& keyName,
460  RegistryKeyNames& rSubKeyNames);
461 
467  inline RegError closeSubKeys(RegistryKeyArray& rSubKeys);
468 
474  inline RegError deleteKey(const ::rtl::OUString& keyName);
475 
477  inline RegError closeKey();
478 
480  inline void releaseKey();
481 
492  inline RegError setValue(const ::rtl::OUString& keyName,
493  RegValueType valueType,
494  RegValue pValue,
495  sal_uInt32 valueSize);
496 
506  inline RegError setLongListValue(const ::rtl::OUString& keyName,
507  sal_Int32* pValueList,
508  sal_uInt32 len);
509 
519  inline RegError setStringListValue(const ::rtl::OUString& keyName,
520  sal_Char** pValueList,
521  sal_uInt32 len);
522 
532  inline RegError setUnicodeListValue(const ::rtl::OUString& keyName,
533  sal_Unicode** pValueList,
534  sal_uInt32 len);
535 
545  inline RegError getValueInfo(const ::rtl::OUString& keyName,
546  RegValueType* pValueType,
547  sal_uInt32* pValueSize);
548 
557  inline RegError getValue(const ::rtl::OUString& keyName,
558  RegValue pValue);
559 
568  inline RegError getLongListValue(const ::rtl::OUString& keyName,
569  RegistryValueList<sal_Int32>& rValueList);
570 
579  inline RegError getStringListValue(const ::rtl::OUString& keyName,
580  RegistryValueList<sal_Char*>& rValueList);
581 
590  inline RegError getUnicodeListValue(const ::rtl::OUString& keyName,
591  RegistryValueList<sal_Unicode*>& rValueList);
592 
599  inline RegError createLink(const ::rtl::OUString& linkName,
600  const ::rtl::OUString& linkTarget);
601 
608  inline RegError deleteLink(const ::rtl::OUString& linkName);
609 
616  inline RegError getKeyType(const ::rtl::OUString& name,
617  RegKeyType* pKeyType) const;
618 
625  inline RegError getLinkTarget(const ::rtl::OUString& linkName,
626  ::rtl::OUString& rLinkTarget) const;
627 
635  inline RegError getResolvedKeyName(const ::rtl::OUString& keyName,
636  sal_Bool firstLinkOnly,
637  ::rtl::OUString& rResolvedName) const;
638 
640  inline ::rtl::OUString getRegistryName();
641 
643  Registry getRegistry() const { return m_registry; }
644 
645  friend class Registry;
646 public:
648 
653  inline RegistryKey(Registry& registry,
654  RegKeyHandle hKey);
655 
658  RegKeyHandle getKeyHandle() const { return m_hImpl; }
659 
660 protected:
663  inline void setRegistry(Registry& registry);
664 
666 
671 };
672 
673 
674 //-----------------------------------------------------------------------------
675 
677  : m_length(0)
678  , m_phKeys(NULL)
679 {
680 }
681 
683 {
684  if (m_phKeys)
685  m_registry.m_pApi->closeSubKeys(m_phKeys, m_length);
686 }
687 
689 {
690  if (m_registry.isValid() && index < m_length)
691  return RegistryKey(m_registry, m_phKeys[index]);
692  else
693  return RegistryKey();
694 }
695 
696 inline sal_uInt32 RegistryKeyArray::getLength()
697 {
698  return m_length;
699 }
700 
702  RegKeyHandle* phKeys,
703  sal_uInt32 length)
704 {
705  m_phKeys = phKeys;
706  m_length = length;
707  m_registry = registry;
708 }
709 
711 {
712  if (m_registry.isValid() && m_phKeys)
713  {
714  RegError ret;
715  ret = m_registry.m_pApi->closeSubKeys(m_phKeys, m_length);
716  m_registry = Registry();
717  m_length = 0;
718  m_phKeys = NULL;
719  return ret;
720  } else
721  return(REG_INVALID_KEY);
722 }
723 
724 //-----------------------------------------------------------------------------
725 
727  : m_length(0)
728  , m_pKeyNames(NULL)
729 {
730 }
731 
733 {
734  if (m_pKeyNames)
735  m_registry.m_pApi->freeKeyNames(m_pKeyNames, m_length);
736 }
737 
738 inline ::rtl::OUString RegistryKeyNames::getElement(sal_uInt32 index)
739 {
740 
741  if (m_pKeyNames && index < m_length)
742  return m_pKeyNames[index];
743  else
744  return ::rtl::OUString();
745 }
746 
747 inline sal_uInt32 RegistryKeyNames::getLength()
748 {
749  return m_length;
750 }
751 
753  rtl_uString** pKeyNames,
754  sal_uInt32 length)
755 {
756  m_pKeyNames = pKeyNames;
757  m_length = length;
758  m_registry = registry;
759 }
760 
762 {
763  if (m_registry.isValid() && m_pKeyNames)
764  {
765  RegError ret = REG_NO_ERROR;
766  ret = m_registry.m_pApi->freeKeyNames(m_pKeyNames, m_length);
767  m_registry = Registry();
768  m_length = 0;
769  m_pKeyNames = NULL;
770  return ret;
771  } else
772  return REG_INVALID_KEY;
773 }
774 
775 //-----------------------------------------------------------------------------
776 
778  : m_hImpl(NULL)
779  { }
780 
782 inline RegistryKey::RegistryKey(Registry& registry, RegKeyHandle hKey)
783  : m_registry(registry)
784  , m_hImpl(hKey)
785  {
786  if (m_hImpl)
787  m_registry.m_pApi->acquireKey(m_hImpl);
788  }
790 
792  : m_registry(toCopy.m_registry)
793  , m_hImpl(toCopy.m_hImpl)
794  {
795  if (m_hImpl)
796  m_registry.m_pApi->acquireKey(m_hImpl);
797  }
798 
800 inline void RegistryKey::setRegistry(Registry& registry)
801  {
802  m_registry = registry;
803  }
805 
807  {
808  if (m_hImpl)
809  m_registry.m_pApi->releaseKey(m_hImpl);
810  }
811 
813 {
814  m_registry = toAssign.m_registry;
815 
816  if (toAssign.m_hImpl)
817  m_registry.m_pApi->acquireKey(toAssign.m_hImpl);
818  if (m_hImpl)
819  m_registry.m_pApi->releaseKey(m_hImpl);
820  m_hImpl = toAssign.m_hImpl;
821 
822  return *this;
823 }
824 
826  { return (m_hImpl != NULL); }
827 
829  {
830  if (m_registry.isValid())
831  return (m_registry.m_pApi)->isKeyReadOnly(m_hImpl);
832  else
833  return sal_False;
834  }
835 
836 inline ::rtl::OUString RegistryKey::getName()
837  {
838  ::rtl::OUString sRet;
839  if (m_registry.isValid())
840  m_registry.m_pApi->getKeyName(m_hImpl, &sRet.pData);
841  return sRet;
842  }
843 
844 inline RegError RegistryKey::createKey(const ::rtl::OUString& keyName,
845  RegistryKey& rNewKey)
846  {
847  if (rNewKey.isValid()) rNewKey.closeKey();
848  if (m_registry.isValid())
849  {
850  RegError ret = m_registry.m_pApi->createKey(m_hImpl, keyName.pData, &rNewKey.m_hImpl);
851  if (!ret) rNewKey.setRegistry(m_registry);
852  return ret;
853  } else
854  return REG_INVALID_KEY;
855  }
856 
857 inline RegError RegistryKey::openKey(const ::rtl::OUString& keyName,
858  RegistryKey& rOpenKey)
859  {
860  if (rOpenKey.isValid()) rOpenKey.closeKey();
861  if (m_registry.isValid())
862  {
863  RegError ret = m_registry.m_pApi->openKey(m_hImpl, keyName.pData,
864  &rOpenKey.m_hImpl);
865  if (!ret) rOpenKey.setRegistry(m_registry);
866  return ret;
867  } else
868  return REG_INVALID_KEY;
869  }
870 
871 inline RegError RegistryKey::openSubKeys(const ::rtl::OUString& keyName,
872  RegistryKeyArray& rSubKeys)
873  {
874  if (m_registry.isValid())
875  {
876  RegError ret = REG_NO_ERROR;
877  RegKeyHandle* pSubKeys;
878  sal_uInt32 nSubKeys;
879  ret = m_registry.m_pApi->openSubKeys(m_hImpl, keyName.pData,
880  &pSubKeys, &nSubKeys);
881  if ( ret )
882  {
883  return ret;
884  } else
885  {
886  rSubKeys.setKeyHandles(m_registry, pSubKeys, nSubKeys);
887  return ret;
888  }
889  } else
890  return REG_INVALID_KEY;
891  }
892 
893 inline RegError RegistryKey::getKeyNames(const ::rtl::OUString& keyName,
894  RegistryKeyNames& rSubKeyNames)
895  {
896  if (m_registry.isValid())
897  {
898  RegError ret = REG_NO_ERROR;
899  rtl_uString** pSubKeyNames;
900  sal_uInt32 nSubKeys;
901  ret = m_registry.m_pApi->getKeyNames(m_hImpl, keyName.pData,
902  &pSubKeyNames, &nSubKeys);
903  if ( ret )
904  {
905  return ret;
906  } else
907  {
908  rSubKeyNames.setKeyNames(m_registry, pSubKeyNames, nSubKeys);
909  return ret;
910  }
911  } else
912  return REG_INVALID_KEY;
913  }
914 
916  {
917  if (m_registry.isValid())
918  return rSubKeys.closeKeyHandles();
919  else
920  return REG_INVALID_KEY;
921  }
922 
923 inline RegError RegistryKey::deleteKey(const ::rtl::OUString& keyName)
924  {
925  if (m_registry.isValid())
926  return m_registry.m_pApi->deleteKey(m_hImpl, keyName.pData);
927  else
928  return REG_INVALID_KEY;
929  }
930 
932  {
933  if (m_registry.isValid())
934  {
935  RegError ret = m_registry.m_pApi->closeKey(m_hImpl);
936  if (!ret)
937  {
938  m_hImpl = NULL;
939  m_registry = Registry();
940  }
941  return ret;
942  } else
943  return REG_INVALID_KEY;
944  }
945 
947 {
948  if (m_registry.isValid() && (m_hImpl != 0))
949  {
950  m_registry.m_pApi->releaseKey(m_hImpl), m_hImpl = 0;
951  }
952 }
953 
954 inline RegError RegistryKey::setValue(const ::rtl::OUString& keyName,
955  RegValueType valueType,
956  RegValue pValue,
957  sal_uInt32 valueSize)
958  {
959  if (m_registry.isValid())
960  return m_registry.m_pApi->setValue(m_hImpl, keyName.pData, valueType,
961  pValue, valueSize);
962  else
963  return REG_INVALID_KEY;
964  }
965 
966 inline RegError RegistryKey::setLongListValue(const ::rtl::OUString& keyName,
967  sal_Int32* pValueList,
968  sal_uInt32 len)
969  {
970  if (m_registry.isValid())
971  return m_registry.m_pApi->setLongListValue(m_hImpl, keyName.pData,
972  pValueList, len);
973  else
974  return REG_INVALID_KEY;
975  }
976 
977 inline RegError RegistryKey::setStringListValue(const ::rtl::OUString& keyName,
978  sal_Char** pValueList,
979  sal_uInt32 len)
980  {
981  if (m_registry.isValid())
982  return m_registry.m_pApi->setStringListValue(m_hImpl, keyName.pData,
983  pValueList, len);
984  else
985  return REG_INVALID_KEY;
986  }
987 
988 inline RegError RegistryKey::setUnicodeListValue(const ::rtl::OUString& keyName,
989  sal_Unicode** pValueList,
990  sal_uInt32 len)
991  {
992  if (m_registry.isValid())
993  return m_registry.m_pApi->setUnicodeListValue(m_hImpl, keyName.pData,
994  pValueList, len);
995  else
996  return REG_INVALID_KEY;
997  }
998 
999 inline RegError RegistryKey::getValueInfo(const ::rtl::OUString& keyName,
1000  RegValueType* pValueType,
1001  sal_uInt32* pValueSize)
1002  {
1003  if (m_registry.isValid())
1004  return m_registry.m_pApi->getValueInfo(m_hImpl, keyName.pData, pValueType, pValueSize);
1005  else
1006  return REG_INVALID_KEY;
1007  }
1008 
1009 inline RegError RegistryKey::getValue(const ::rtl::OUString& keyName,
1010  RegValue pValue)
1011  {
1012  if (m_registry.isValid())
1013  return m_registry.m_pApi->getValue(m_hImpl, keyName.pData, pValue);
1014  else
1015  return REG_INVALID_KEY;
1016  }
1017 
1018 inline RegError RegistryKey::getLongListValue(const ::rtl::OUString& keyName,
1019  RegistryValueList<sal_Int32>& rValueList)
1020  {
1021  if (m_registry.isValid())
1022  {
1023  RegError ret = REG_NO_ERROR;
1024  sal_Int32* pValueList;
1025  sal_uInt32 length;
1026  ret = m_registry.m_pApi->getLongListValue(m_hImpl, keyName.pData,
1027  &pValueList, &length);
1028  if ( ret )
1029  {
1030  return ret;
1031  } else
1032  {
1034  pValueList, length);
1035  return ret;
1036  }
1037  } else
1038  return REG_INVALID_KEY;
1039  }
1040 
1041 inline RegError RegistryKey::getStringListValue(const ::rtl::OUString& keyName,
1042  RegistryValueList<sal_Char*>& rValueList)
1043  {
1044  if (m_registry.isValid())
1045  {
1046  RegError ret = REG_NO_ERROR;
1047  sal_Char** pValueList;
1048  sal_uInt32 length;
1049  ret = m_registry.m_pApi->getStringListValue(m_hImpl, keyName.pData,
1050  &pValueList, &length);
1051  if ( ret )
1052  {
1053  return ret;
1054  } else
1055  {
1057  pValueList, length);
1058  return ret;
1059  }
1060  } else
1061  return REG_INVALID_KEY;
1062  }
1063 
1064 inline RegError RegistryKey::getUnicodeListValue(const ::rtl::OUString& keyName,
1065  RegistryValueList<sal_Unicode*>& rValueList)
1066  {
1067  if (m_registry.isValid())
1068  {
1069  RegError ret = REG_NO_ERROR;
1070  sal_Unicode** pValueList;
1071  sal_uInt32 length;
1072  ret = m_registry.m_pApi->getUnicodeListValue(m_hImpl, keyName.pData,
1073  &pValueList, &length);
1074  if ( ret )
1075  {
1076  return ret;
1077  } else
1078  {
1080  pValueList, length);
1081  return ret;
1082  }
1083  } else
1084  return REG_INVALID_KEY;
1085  }
1086 
1087 inline RegError RegistryKey::createLink(const ::rtl::OUString& linkName,
1088  const ::rtl::OUString& linkTarget)
1089  {
1090  if (m_registry.isValid())
1091  return m_registry.m_pApi->createLink(m_hImpl, linkName.pData, linkTarget.pData);
1092  else
1093  return REG_INVALID_KEY;
1094  }
1095 
1096 inline RegError RegistryKey::deleteLink(const ::rtl::OUString& linkName)
1097  {
1098  if (m_registry.isValid())
1099  return m_registry.m_pApi->deleteLink(m_hImpl, linkName.pData);
1100  else
1101  return REG_INVALID_KEY;
1102  }
1103 
1104 inline RegError RegistryKey::getKeyType(const ::rtl::OUString& keyName,
1105  RegKeyType* pKeyType) const
1106  {
1107  if (m_registry.isValid())
1108  return m_registry.m_pApi->getKeyType(m_hImpl, keyName.pData, pKeyType);
1109  else
1110  return REG_INVALID_KEY;
1111  }
1112 
1113 inline RegError RegistryKey::getLinkTarget(const ::rtl::OUString& linkName,
1114  ::rtl::OUString& rLinkTarget) const
1115  {
1116  if (m_registry.isValid())
1117  {
1118  return m_registry.m_pApi->getLinkTarget(m_hImpl,
1119  linkName.pData,
1120  &rLinkTarget.pData);
1121  } else
1122  return REG_INVALID_KEY;
1123  }
1124 
1125 
1126 inline RegError RegistryKey::getResolvedKeyName(const ::rtl::OUString& keyName,
1127  sal_Bool firstLinkOnly,
1128  ::rtl::OUString& rResolvedName) const
1129  {
1130  if (m_registry.isValid())
1131  return m_registry.m_pApi->getResolvedKeyName(m_hImpl,
1132  keyName.pData,
1133  firstLinkOnly,
1134  &rResolvedName.pData);
1135  else
1136  return REG_INVALID_KEY;
1137  }
1138 
1139 inline ::rtl::OUString RegistryKey::getRegistryName()
1140  {
1141  if (m_registry.isValid())
1142  {
1143  return m_registry.getName();
1144  } else
1145  return ::rtl::OUString();
1146  }
1147 
1148 //-----------------------------------------------------------------------------
1149 
1152  , m_hImpl(NULL)
1153  { }
1154 
1155 inline Registry::Registry(const Registry& toCopy)
1156  : m_pApi(toCopy.m_pApi)
1157  , m_hImpl(toCopy.m_hImpl)
1158  {
1159  if (m_hImpl)
1160  m_pApi->acquire(m_hImpl);
1161  }
1162 
1163 
1165  {
1166  if (m_hImpl)
1167  m_pApi->release(m_hImpl);
1168  }
1169 
1170 inline Registry& Registry::operator = (const Registry& toAssign)
1171 {
1172  if (toAssign.m_hImpl)
1173  toAssign.m_pApi->acquire(toAssign.m_hImpl);
1174  if (m_hImpl)
1175  m_pApi->release(m_hImpl);
1176 
1177  m_pApi = toAssign.m_pApi;
1178  m_hImpl = toAssign.m_hImpl;
1179 
1180  return *this;
1181 }
1182 
1184  { return ( m_hImpl != NULL ); }
1185 
1187  { return m_pApi->isReadOnly(m_hImpl); }
1188 
1190  {
1191  rRootKey.setRegistry(*this);
1192  return m_pApi->openRootKey(m_hImpl, &rRootKey.m_hImpl);
1193  }
1194 
1195 inline ::rtl::OUString Registry::getName()
1196  {
1197  ::rtl::OUString sRet;
1198  m_pApi->getName(m_hImpl, &sRet.pData);
1199  return sRet;
1200  }
1201 
1202 inline RegError Registry::create(const ::rtl::OUString& registryName)
1203  {
1204  if (m_hImpl)
1205  m_pApi->release(m_hImpl);
1206  return m_pApi->createRegistry(registryName.pData, &m_hImpl);
1207  }
1208 
1209 inline RegError Registry::open(const ::rtl::OUString& registryName,
1210  RegAccessMode accessMode)
1211  {
1212  if (m_hImpl)
1213  m_pApi->release(m_hImpl);
1214  return m_pApi->openRegistry(registryName.pData, &m_hImpl, accessMode);
1215  }
1216 
1218  {
1219  RegError ret = m_pApi->closeRegistry(m_hImpl);
1220  if (!ret)
1221  m_hImpl = NULL;
1222  return ret;
1223  }
1224 
1225 inline RegError Registry::destroy(const ::rtl::OUString& registryName)
1226  {
1227  RegError ret = m_pApi->destroyRegistry(m_hImpl, registryName.pData);
1228  if ( !ret && registryName.isEmpty() )
1229  m_hImpl = NULL;
1230  return ret;
1231  }
1232 
1234  const ::rtl::OUString& keyName,
1235  const ::rtl::OUString& regFileName)
1236  { return m_pApi->loadKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData); }
1237 
1239  const ::rtl::OUString& keyName,
1240  const ::rtl::OUString& regFileName)
1241  { return m_pApi->saveKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData); }
1242 
1244  const ::rtl::OUString& keyName,
1245  const ::rtl::OUString& regFileName,
1246  sal_Bool bWarnings,
1247  sal_Bool bReport)
1248  { return m_pApi->mergeKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData, bWarnings, bReport); }
1249 
1251  { return m_pApi->dumpRegistry(m_hImpl, rKey.m_hImpl); }
1252 
1253 
1254 #endif
1255 
1256 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */