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  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * Copyright 2000, 2010 Oracle and/or its affiliates.
7  *
8  * OpenOffice.org - a multi-platform office productivity suite
9  *
10  * This file is part of OpenOffice.org.
11  *
12  * OpenOffice.org is free software: you can redistribute it and/or modify
13  * it under the terms of the GNU Lesser General Public License version 3
14  * only, as published by the Free Software Foundation.
15  *
16  * OpenOffice.org is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU Lesser General Public License version 3 for more details
20  * (a copy is included in the LICENSE file that accompanied this code).
21  *
22  * You should have received a copy of the GNU Lesser General Public License
23  * version 3 along with OpenOffice.org. If not, see
24  * <http://www.openoffice.org/license.html>
25  * for a copy of the LGPLv3 License.
26  *
27  ************************************************************************/
28 
29 #ifndef _REGISTRY_REGISTRY_HXX_
30 #define _REGISTRY_REGISTRY_HXX_
31 
32 #include <registry/regdllapi.h>
33 #include <registry/regtype.h>
34 #include <rtl/ustring.hxx>
35 
36 #ifdef __cplusplus
37 extern "C" {
38 #endif
39 
45 {
46  void (REGISTRY_CALLTYPE *acquire) (RegHandle);
47  void (REGISTRY_CALLTYPE *release) (RegHandle);
48  sal_Bool (REGISTRY_CALLTYPE *isReadOnly) (RegHandle);
50  RegError (REGISTRY_CALLTYPE *getName) (RegHandle, rtl_uString**);
51  RegError (REGISTRY_CALLTYPE *createRegistry) (rtl_uString*, RegHandle*);
52  RegError (REGISTRY_CALLTYPE *openRegistry) (rtl_uString*, RegHandle*, RegAccessMode);
53  RegError (REGISTRY_CALLTYPE *closeRegistry) (RegHandle);
54  RegError (REGISTRY_CALLTYPE *destroyRegistry) (RegHandle, rtl_uString*);
55  RegError (REGISTRY_CALLTYPE *loadKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*);
56  RegError (REGISTRY_CALLTYPE *saveKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*);
57  RegError (REGISTRY_CALLTYPE *mergeKey) (RegHandle, RegKeyHandle, rtl_uString*, rtl_uString*, sal_Bool, sal_Bool);
59  void (REGISTRY_CALLTYPE *acquireKey) (RegKeyHandle);
60  void (REGISTRY_CALLTYPE *releaseKey) (RegKeyHandle);
61  sal_Bool (REGISTRY_CALLTYPE *isKeyReadOnly) (RegKeyHandle);
62  RegError (REGISTRY_CALLTYPE *getKeyName) (RegKeyHandle, rtl_uString**);
63  RegError (REGISTRY_CALLTYPE *createKey) (RegKeyHandle, rtl_uString*, RegKeyHandle*);
64  RegError (REGISTRY_CALLTYPE *openKey) (RegKeyHandle, rtl_uString*, RegKeyHandle*);
65  RegError (REGISTRY_CALLTYPE *openSubKeys) (RegKeyHandle, rtl_uString*, RegKeyHandle**, sal_uInt32*);
67  RegError (REGISTRY_CALLTYPE *deleteKey) (RegKeyHandle, rtl_uString*);
70  RegError (REGISTRY_CALLTYPE *setLongListValue) (RegKeyHandle, rtl_uString*, sal_Int32*, sal_uInt32);
71  RegError (REGISTRY_CALLTYPE *setStringListValue) (RegKeyHandle, rtl_uString*, sal_Char**, sal_uInt32);
72  RegError (REGISTRY_CALLTYPE *setUnicodeListValue)(RegKeyHandle, rtl_uString*, sal_Unicode**, sal_uInt32);
73  RegError (REGISTRY_CALLTYPE *getValueInfo) (RegKeyHandle, rtl_uString*, RegValueType*, sal_uInt32*);
74  RegError (REGISTRY_CALLTYPE *getValue) (RegKeyHandle, rtl_uString*, RegValue);
75  RegError (REGISTRY_CALLTYPE *getLongListValue) (RegKeyHandle, rtl_uString*, sal_Int32**, sal_uInt32*);
76  RegError (REGISTRY_CALLTYPE *getStringListValue) (RegKeyHandle, rtl_uString*, sal_Char***, sal_uInt32*);
77  RegError (REGISTRY_CALLTYPE *getUnicodeListValue)(RegKeyHandle, rtl_uString*, sal_Unicode***, sal_uInt32*);
79  RegError (REGISTRY_CALLTYPE *createLink) (RegKeyHandle, rtl_uString*, rtl_uString*);
80  RegError (REGISTRY_CALLTYPE *deleteLink) (RegKeyHandle, rtl_uString*);
81  RegError (REGISTRY_CALLTYPE *getKeyType) (RegKeyHandle, rtl_uString*, RegKeyType*);
82  RegError (REGISTRY_CALLTYPE *getLinkTarget) (RegKeyHandle, rtl_uString*, rtl_uString**);
83  RegError (REGISTRY_CALLTYPE *getResolvedKeyName) (RegKeyHandle, rtl_uString*, sal_Bool, rtl_uString**);
84  RegError (REGISTRY_CALLTYPE *getKeyNames) (RegKeyHandle, rtl_uString*, rtl_uString***, sal_uInt32*);
85  RegError (REGISTRY_CALLTYPE *freeKeyNames) (rtl_uString**, sal_uInt32);
86 };
87 
91 
92 #ifdef __cplusplus
93 }
94 #endif
95 
96 
97 class RegistryKey;
98 
99 //-----------------------------------------------------------------------------
100 
105 class Registry
106 {
107 public:
110  inline Registry();
111 
113  inline Registry(const Registry& toCopy);
114 
116  inline ~Registry();
117 
119  inline Registry& operator = (const Registry& toAssign);
120 
122  inline sal_Bool isValid() const;
123 
128  inline sal_Bool isReadOnly() const;
129 
135  inline RegError openRootKey(RegistryKey& rRootKey);
136 
138  inline ::rtl::OUString getName();
139 
145  inline RegError create(const ::rtl::OUString& registryName);
146 
154  inline RegError open(const ::rtl::OUString& registryName,
155  RegAccessMode accessMode);
156 
158  inline RegError close();
159 
166  inline RegError destroy(const ::rtl::OUString& registryName);
167 
179  inline RegError loadKey(RegistryKey& rKey,
180  const ::rtl::OUString& keyName,
181  const ::rtl::OUString& regFileName);
182 
194  inline RegError saveKey(RegistryKey& rKey,
195  const ::rtl::OUString& keyName,
196  const ::rtl::OUString& regFileName);
197 
213  inline RegError mergeKey(RegistryKey& rKey,
214  const ::rtl::OUString& keyName,
215  const ::rtl::OUString& regFileName,
216  sal_Bool bWarnings = sal_False,
217  sal_Bool bReport = sal_False);
218 
226  inline RegError dumpRegistry(RegistryKey& rKey);
227 
228  friend class RegistryKey;
229  friend class RegistryKeyArray;
230  friend class RegistryKeyNames;
231 
233  const Registry_Api* getApi() { return m_pApi; }
234 protected:
235 
240 };
241 
242 
243 //-----------------------------------------------------------------------------
244 
250 {
251 public:
253  inline RegistryKeyArray();
254 
256  inline ~RegistryKeyArray();
257 
259  inline RegistryKey getElement(sal_uInt32 index);
260 
262  inline sal_uInt32 getLength();
263 
264  friend class RegistryKey;
265 protected:
272  inline void setKeyHandles(Registry& registry, RegKeyHandle* phKeys, sal_uInt32 length);
274  inline RegError closeKeyHandles();
275 
277  sal_uInt32 m_length;
282 };
283 
284 
290 {
291 public:
293  inline RegistryKeyNames();
294 
296  inline ~RegistryKeyNames();
297 
299  inline ::rtl::OUString getElement(sal_uInt32 index);
300 
302  inline sal_uInt32 getLength();
303 
304  friend class RegistryKey;
305 protected:
312  inline void setKeyNames(Registry& registry, rtl_uString** pKeyNames, sal_uInt32 length);
314  inline RegError freeKeyNames();
315 
317  sal_uInt32 m_length;
319  rtl_uString** m_pKeyNames;
322 };
323 
324 //-----------------------------------------------------------------------------
325 
330 template<class ValueType>
332 {
333 public:
336  : m_length(0)
337  , m_pValueList(NULL)
339  {}
340 
343  {
344  if (m_pValueList)
345  {
346  m_registry.getApi()->freeValueList(m_valueType, m_pValueList, m_length);
347  }
348  }
349 
351  ValueType getElement(sal_uInt32 index)
352  {
353  if (m_registry.isValid() && index < m_length)
354  {
355  return m_pValueList[index];
356  } else
357  {
358  return 0;
359  }
360  }
361 
363  sal_uInt32 getLength()
364  {
365  return m_length;
366  }
367 
368  friend class RegistryKey;
369 protected:
377  void setValueList(Registry& registry, RegValueType valueType,
378  ValueType* pValueList, sal_uInt32 length)
379  {
380  m_length = length;
381  m_pValueList = pValueList;
382  m_valueType = valueType;
383  m_registry = registry;
384  }
385 
387  sal_uInt32 m_length;
389  ValueType* m_pValueList;
396 };
397 
398 //-----------------------------------------------------------------------------
399 
405 {
406 public:
408  inline RegistryKey();
409 
411  inline RegistryKey(const RegistryKey& toCopy);
412 
414  inline ~RegistryKey();
415 
417  inline RegistryKey& operator = (const RegistryKey& toAssign);
418 
420  inline sal_Bool isValid() const;
421 
426  inline sal_Bool isReadOnly() const;
427 
429  inline ::rtl::OUString getName();
430 
438  inline RegError createKey(const ::rtl::OUString& keyName,
439  RegistryKey& rNewKey);
440 
448  inline RegError openKey(const ::rtl::OUString& keyName,
449  RegistryKey& rOpenKey);
450 
458  inline RegError openSubKeys(const ::rtl::OUString& keyName,
459  RegistryKeyArray& rSubKeys);
460 
468  inline RegError getKeyNames(const ::rtl::OUString& keyName,
469  RegistryKeyNames& rSubKeyNames);
470 
476  inline RegError closeSubKeys(RegistryKeyArray& rSubKeys);
477 
483  inline RegError deleteKey(const ::rtl::OUString& keyName);
484 
486  inline RegError closeKey();
487 
489  inline void releaseKey();
490 
501  inline RegError setValue(const ::rtl::OUString& keyName,
502  RegValueType valueType,
503  RegValue pValue,
504  sal_uInt32 valueSize);
505 
515  inline RegError setLongListValue(const ::rtl::OUString& keyName,
516  sal_Int32* pValueList,
517  sal_uInt32 len);
518 
528  inline RegError setStringListValue(const ::rtl::OUString& keyName,
529  sal_Char** pValueList,
530  sal_uInt32 len);
531 
541  inline RegError setUnicodeListValue(const ::rtl::OUString& keyName,
542  sal_Unicode** pValueList,
543  sal_uInt32 len);
544 
554  inline RegError getValueInfo(const ::rtl::OUString& keyName,
555  RegValueType* pValueType,
556  sal_uInt32* pValueSize);
557 
566  inline RegError getValue(const ::rtl::OUString& keyName,
567  RegValue pValue);
568 
577  inline RegError getLongListValue(const ::rtl::OUString& keyName,
578  RegistryValueList<sal_Int32>& rValueList);
579 
588  inline RegError getStringListValue(const ::rtl::OUString& keyName,
589  RegistryValueList<sal_Char*>& rValueList);
590 
599  inline RegError getUnicodeListValue(const ::rtl::OUString& keyName,
600  RegistryValueList<sal_Unicode*>& rValueList);
601 
608  inline RegError createLink(const ::rtl::OUString& linkName,
609  const ::rtl::OUString& linkTarget);
610 
617  inline RegError deleteLink(const ::rtl::OUString& linkName);
618 
625  inline RegError getKeyType(const ::rtl::OUString& name,
626  RegKeyType* pKeyType) const;
627 
634  inline RegError getLinkTarget(const ::rtl::OUString& linkName,
635  ::rtl::OUString& rLinkTarget) const;
636 
644  inline RegError getResolvedKeyName(const ::rtl::OUString& keyName,
645  sal_Bool firstLinkOnly,
646  ::rtl::OUString& rResolvedName) const;
647 
649  inline ::rtl::OUString getRegistryName();
650 
652  Registry getRegistry() const { return m_registry; }
653 
654  friend class Registry;
655 public:
657 
662  inline RegistryKey(Registry& registry,
663  RegKeyHandle hKey);
664 
667  RegKeyHandle getKeyHandle() const { return m_hImpl; }
668 
669 protected:
672  inline void setRegistry(Registry& registry);
673 
675 
680 };
681 
682 
683 //-----------------------------------------------------------------------------
684 
686  : m_length(0)
687  , m_phKeys(NULL)
688 {
689 }
690 
692 {
693  if (m_phKeys)
694  m_registry.m_pApi->closeSubKeys(m_phKeys, m_length);
695 }
696 
698 {
699  if (m_registry.isValid() && index < m_length)
700  return RegistryKey(m_registry, m_phKeys[index]);
701  else
702  return RegistryKey();
703 }
704 
705 inline sal_uInt32 RegistryKeyArray::getLength()
706 {
707  return m_length;
708 }
709 
711  RegKeyHandle* phKeys,
712  sal_uInt32 length)
713 {
714  m_phKeys = phKeys;
715  m_length = length;
716  m_registry = registry;
717 }
718 
720 {
721  if (m_registry.isValid() && m_phKeys)
722  {
723  RegError ret;
724  ret = m_registry.m_pApi->closeSubKeys(m_phKeys, m_length);
725  m_registry = Registry();
726  m_length = 0;
727  m_phKeys = NULL;
728  return ret;
729  } else
730  return(REG_INVALID_KEY);
731 }
732 
733 //-----------------------------------------------------------------------------
734 
736  : m_length(0)
737  , m_pKeyNames(NULL)
738 {
739 }
740 
742 {
743  if (m_pKeyNames)
744  m_registry.m_pApi->freeKeyNames(m_pKeyNames, m_length);
745 }
746 
747 inline ::rtl::OUString RegistryKeyNames::getElement(sal_uInt32 index)
748 {
749 
750  if (m_pKeyNames && index < m_length)
751  return m_pKeyNames[index];
752  else
753  return ::rtl::OUString();
754 }
755 
756 inline sal_uInt32 RegistryKeyNames::getLength()
757 {
758  return m_length;
759 }
760 
762  rtl_uString** pKeyNames,
763  sal_uInt32 length)
764 {
765  m_pKeyNames = pKeyNames;
766  m_length = length;
767  m_registry = registry;
768 }
769 
771 {
772  if (m_registry.isValid() && m_pKeyNames)
773  {
774  RegError ret = REG_NO_ERROR;
775  ret = m_registry.m_pApi->freeKeyNames(m_pKeyNames, m_length);
776  m_registry = Registry();
777  m_length = 0;
778  m_pKeyNames = NULL;
779  return ret;
780  } else
781  return REG_INVALID_KEY;
782 }
783 
784 //-----------------------------------------------------------------------------
785 
787  : m_hImpl(NULL)
788  { }
789 
791 inline RegistryKey::RegistryKey(Registry& registry, RegKeyHandle hKey)
792  : m_registry(registry)
793  , m_hImpl(hKey)
794  {
795  if (m_hImpl)
796  m_registry.m_pApi->acquireKey(m_hImpl);
797  }
799 
801  : m_registry(toCopy.m_registry)
802  , m_hImpl(toCopy.m_hImpl)
803  {
804  if (m_hImpl)
805  m_registry.m_pApi->acquireKey(m_hImpl);
806  }
807 
809 inline void RegistryKey::setRegistry(Registry& registry)
810  {
811  m_registry = registry;
812  }
814 
816  {
817  if (m_hImpl)
818  m_registry.m_pApi->releaseKey(m_hImpl);
819  }
820 
822 {
823  m_registry = toAssign.m_registry;
824 
825  if (toAssign.m_hImpl)
826  m_registry.m_pApi->acquireKey(toAssign.m_hImpl);
827  if (m_hImpl)
828  m_registry.m_pApi->releaseKey(m_hImpl);
829  m_hImpl = toAssign.m_hImpl;
830 
831  return *this;
832 }
833 
835  { return (m_hImpl != NULL); }
836 
838  {
839  if (m_registry.isValid())
840  return (m_registry.m_pApi)->isKeyReadOnly(m_hImpl);
841  else
842  return sal_False;
843  }
844 
845 inline ::rtl::OUString RegistryKey::getName()
846  {
847  ::rtl::OUString sRet;
848  if (m_registry.isValid())
849  m_registry.m_pApi->getKeyName(m_hImpl, &sRet.pData);
850  return sRet;
851  }
852 
853 inline RegError RegistryKey::createKey(const ::rtl::OUString& keyName,
854  RegistryKey& rNewKey)
855  {
856  if (rNewKey.isValid()) rNewKey.closeKey();
857  if (m_registry.isValid())
858  {
859  RegError ret = m_registry.m_pApi->createKey(m_hImpl, keyName.pData, &rNewKey.m_hImpl);
860  if (!ret) rNewKey.setRegistry(m_registry);
861  return ret;
862  } else
863  return REG_INVALID_KEY;
864  }
865 
866 inline RegError RegistryKey::openKey(const ::rtl::OUString& keyName,
867  RegistryKey& rOpenKey)
868  {
869  if (rOpenKey.isValid()) rOpenKey.closeKey();
870  if (m_registry.isValid())
871  {
872  RegError ret = m_registry.m_pApi->openKey(m_hImpl, keyName.pData,
873  &rOpenKey.m_hImpl);
874  if (!ret) rOpenKey.setRegistry(m_registry);
875  return ret;
876  } else
877  return REG_INVALID_KEY;
878  }
879 
880 inline RegError RegistryKey::openSubKeys(const ::rtl::OUString& keyName,
881  RegistryKeyArray& rSubKeys)
882  {
883  if (m_registry.isValid())
884  {
885  RegError ret = REG_NO_ERROR;
886  RegKeyHandle* pSubKeys;
887  sal_uInt32 nSubKeys;
888  ret = m_registry.m_pApi->openSubKeys(m_hImpl, keyName.pData,
889  &pSubKeys, &nSubKeys);
890  if ( ret )
891  {
892  return ret;
893  } else
894  {
895  rSubKeys.setKeyHandles(m_registry, pSubKeys, nSubKeys);
896  return ret;
897  }
898  } else
899  return REG_INVALID_KEY;
900  }
901 
902 inline RegError RegistryKey::getKeyNames(const ::rtl::OUString& keyName,
903  RegistryKeyNames& rSubKeyNames)
904  {
905  if (m_registry.isValid())
906  {
907  RegError ret = REG_NO_ERROR;
908  rtl_uString** pSubKeyNames;
909  sal_uInt32 nSubKeys;
910  ret = m_registry.m_pApi->getKeyNames(m_hImpl, keyName.pData,
911  &pSubKeyNames, &nSubKeys);
912  if ( ret )
913  {
914  return ret;
915  } else
916  {
917  rSubKeyNames.setKeyNames(m_registry, pSubKeyNames, nSubKeys);
918  return ret;
919  }
920  } else
921  return REG_INVALID_KEY;
922  }
923 
925  {
926  if (m_registry.isValid())
927  return rSubKeys.closeKeyHandles();
928  else
929  return REG_INVALID_KEY;
930  }
931 
932 inline RegError RegistryKey::deleteKey(const ::rtl::OUString& keyName)
933  {
934  if (m_registry.isValid())
935  return m_registry.m_pApi->deleteKey(m_hImpl, keyName.pData);
936  else
937  return REG_INVALID_KEY;
938  }
939 
941  {
942  if (m_registry.isValid())
943  {
944  RegError ret = m_registry.m_pApi->closeKey(m_hImpl);
945  if (!ret)
946  {
947  m_hImpl = NULL;
948  m_registry = Registry();
949  }
950  return ret;
951  } else
952  return REG_INVALID_KEY;
953  }
954 
956 {
957  if (m_registry.isValid() && (m_hImpl != 0))
958  {
959  m_registry.m_pApi->releaseKey(m_hImpl), m_hImpl = 0;
960  }
961 }
962 
963 inline RegError RegistryKey::setValue(const ::rtl::OUString& keyName,
964  RegValueType valueType,
965  RegValue pValue,
966  sal_uInt32 valueSize)
967  {
968  if (m_registry.isValid())
969  return m_registry.m_pApi->setValue(m_hImpl, keyName.pData, valueType,
970  pValue, valueSize);
971  else
972  return REG_INVALID_KEY;
973  }
974 
975 inline RegError RegistryKey::setLongListValue(const ::rtl::OUString& keyName,
976  sal_Int32* pValueList,
977  sal_uInt32 len)
978  {
979  if (m_registry.isValid())
980  return m_registry.m_pApi->setLongListValue(m_hImpl, keyName.pData,
981  pValueList, len);
982  else
983  return REG_INVALID_KEY;
984  }
985 
986 inline RegError RegistryKey::setStringListValue(const ::rtl::OUString& keyName,
987  sal_Char** pValueList,
988  sal_uInt32 len)
989  {
990  if (m_registry.isValid())
991  return m_registry.m_pApi->setStringListValue(m_hImpl, keyName.pData,
992  pValueList, len);
993  else
994  return REG_INVALID_KEY;
995  }
996 
997 inline RegError RegistryKey::setUnicodeListValue(const ::rtl::OUString& keyName,
998  sal_Unicode** pValueList,
999  sal_uInt32 len)
1000  {
1001  if (m_registry.isValid())
1002  return m_registry.m_pApi->setUnicodeListValue(m_hImpl, keyName.pData,
1003  pValueList, len);
1004  else
1005  return REG_INVALID_KEY;
1006  }
1007 
1008 inline RegError RegistryKey::getValueInfo(const ::rtl::OUString& keyName,
1009  RegValueType* pValueType,
1010  sal_uInt32* pValueSize)
1011  {
1012  if (m_registry.isValid())
1013  return m_registry.m_pApi->getValueInfo(m_hImpl, keyName.pData, pValueType, pValueSize);
1014  else
1015  return REG_INVALID_KEY;
1016  }
1017 
1018 inline RegError RegistryKey::getValue(const ::rtl::OUString& keyName,
1019  RegValue pValue)
1020  {
1021  if (m_registry.isValid())
1022  return m_registry.m_pApi->getValue(m_hImpl, keyName.pData, pValue);
1023  else
1024  return REG_INVALID_KEY;
1025  }
1026 
1027 inline RegError RegistryKey::getLongListValue(const ::rtl::OUString& keyName,
1028  RegistryValueList<sal_Int32>& rValueList)
1029  {
1030  if (m_registry.isValid())
1031  {
1032  RegError ret = REG_NO_ERROR;
1033  sal_Int32* pValueList;
1034  sal_uInt32 length;
1035  ret = m_registry.m_pApi->getLongListValue(m_hImpl, keyName.pData,
1036  &pValueList, &length);
1037  if ( ret )
1038  {
1039  return ret;
1040  } else
1041  {
1043  pValueList, length);
1044  return ret;
1045  }
1046  } else
1047  return REG_INVALID_KEY;
1048  }
1049 
1050 inline RegError RegistryKey::getStringListValue(const ::rtl::OUString& keyName,
1051  RegistryValueList<sal_Char*>& rValueList)
1052  {
1053  if (m_registry.isValid())
1054  {
1055  RegError ret = REG_NO_ERROR;
1056  sal_Char** pValueList;
1057  sal_uInt32 length;
1058  ret = m_registry.m_pApi->getStringListValue(m_hImpl, keyName.pData,
1059  &pValueList, &length);
1060  if ( ret )
1061  {
1062  return ret;
1063  } else
1064  {
1066  pValueList, length);
1067  return ret;
1068  }
1069  } else
1070  return REG_INVALID_KEY;
1071  }
1072 
1073 inline RegError RegistryKey::getUnicodeListValue(const ::rtl::OUString& keyName,
1074  RegistryValueList<sal_Unicode*>& rValueList)
1075  {
1076  if (m_registry.isValid())
1077  {
1078  RegError ret = REG_NO_ERROR;
1079  sal_Unicode** pValueList;
1080  sal_uInt32 length;
1081  ret = m_registry.m_pApi->getUnicodeListValue(m_hImpl, keyName.pData,
1082  &pValueList, &length);
1083  if ( ret )
1084  {
1085  return ret;
1086  } else
1087  {
1089  pValueList, length);
1090  return ret;
1091  }
1092  } else
1093  return REG_INVALID_KEY;
1094  }
1095 
1096 inline RegError RegistryKey::createLink(const ::rtl::OUString& linkName,
1097  const ::rtl::OUString& linkTarget)
1098  {
1099  if (m_registry.isValid())
1100  return m_registry.m_pApi->createLink(m_hImpl, linkName.pData, linkTarget.pData);
1101  else
1102  return REG_INVALID_KEY;
1103  }
1104 
1105 inline RegError RegistryKey::deleteLink(const ::rtl::OUString& linkName)
1106  {
1107  if (m_registry.isValid())
1108  return m_registry.m_pApi->deleteLink(m_hImpl, linkName.pData);
1109  else
1110  return REG_INVALID_KEY;
1111  }
1112 
1113 inline RegError RegistryKey::getKeyType(const ::rtl::OUString& keyName,
1114  RegKeyType* pKeyType) const
1115  {
1116  if (m_registry.isValid())
1117  return m_registry.m_pApi->getKeyType(m_hImpl, keyName.pData, pKeyType);
1118  else
1119  return REG_INVALID_KEY;
1120  }
1121 
1122 inline RegError RegistryKey::getLinkTarget(const ::rtl::OUString& linkName,
1123  ::rtl::OUString& rLinkTarget) const
1124  {
1125  if (m_registry.isValid())
1126  {
1127  return m_registry.m_pApi->getLinkTarget(m_hImpl,
1128  linkName.pData,
1129  &rLinkTarget.pData);
1130  } else
1131  return REG_INVALID_KEY;
1132  }
1133 
1134 
1135 inline RegError RegistryKey::getResolvedKeyName(const ::rtl::OUString& keyName,
1136  sal_Bool firstLinkOnly,
1137  ::rtl::OUString& rResolvedName) const
1138  {
1139  if (m_registry.isValid())
1140  return m_registry.m_pApi->getResolvedKeyName(m_hImpl,
1141  keyName.pData,
1142  firstLinkOnly,
1143  &rResolvedName.pData);
1144  else
1145  return REG_INVALID_KEY;
1146  }
1147 
1148 inline ::rtl::OUString RegistryKey::getRegistryName()
1149  {
1150  if (m_registry.isValid())
1151  {
1152  return m_registry.getName();
1153  } else
1154  return ::rtl::OUString();
1155  }
1156 
1157 //-----------------------------------------------------------------------------
1158 
1161  , m_hImpl(NULL)
1162  { }
1163 
1164 inline Registry::Registry(const Registry& toCopy)
1165  : m_pApi(toCopy.m_pApi)
1166  , m_hImpl(toCopy.m_hImpl)
1167  {
1168  if (m_hImpl)
1169  m_pApi->acquire(m_hImpl);
1170  }
1171 
1172 
1174  {
1175  if (m_hImpl)
1176  m_pApi->release(m_hImpl);
1177  }
1178 
1179 inline Registry& Registry::operator = (const Registry& toAssign)
1180 {
1181  if (toAssign.m_hImpl)
1182  toAssign.m_pApi->acquire(toAssign.m_hImpl);
1183  if (m_hImpl)
1184  m_pApi->release(m_hImpl);
1185 
1186  m_pApi = toAssign.m_pApi;
1187  m_hImpl = toAssign.m_hImpl;
1188 
1189  return *this;
1190 }
1191 
1193  { return ( m_hImpl != NULL ); }
1194 
1196  { return m_pApi->isReadOnly(m_hImpl); }
1197 
1199  {
1200  rRootKey.setRegistry(*this);
1201  return m_pApi->openRootKey(m_hImpl, &rRootKey.m_hImpl);
1202  }
1203 
1204 inline ::rtl::OUString Registry::getName()
1205  {
1206  ::rtl::OUString sRet;
1207  m_pApi->getName(m_hImpl, &sRet.pData);
1208  return sRet;
1209  }
1210 
1211 inline RegError Registry::create(const ::rtl::OUString& registryName)
1212  {
1213  if (m_hImpl)
1214  m_pApi->release(m_hImpl);
1215  return m_pApi->createRegistry(registryName.pData, &m_hImpl);
1216  }
1217 
1218 inline RegError Registry::open(const ::rtl::OUString& registryName,
1219  RegAccessMode accessMode)
1220  {
1221  if (m_hImpl)
1222  m_pApi->release(m_hImpl);
1223  return m_pApi->openRegistry(registryName.pData, &m_hImpl, accessMode);
1224  }
1225 
1227  {
1228  RegError ret = m_pApi->closeRegistry(m_hImpl);
1229  if (!ret)
1230  m_hImpl = NULL;
1231  return ret;
1232  }
1233 
1234 inline RegError Registry::destroy(const ::rtl::OUString& registryName)
1235  {
1236  RegError ret = m_pApi->destroyRegistry(m_hImpl, registryName.pData);
1237  if ( !ret && registryName.isEmpty() )
1238  m_hImpl = NULL;
1239  return ret;
1240  }
1241 
1243  const ::rtl::OUString& keyName,
1244  const ::rtl::OUString& regFileName)
1245  { return m_pApi->loadKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData); }
1246 
1248  const ::rtl::OUString& keyName,
1249  const ::rtl::OUString& regFileName)
1250  { return m_pApi->saveKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData); }
1251 
1253  const ::rtl::OUString& keyName,
1254  const ::rtl::OUString& regFileName,
1255  sal_Bool bWarnings,
1256  sal_Bool bReport)
1257  { return m_pApi->mergeKey(m_hImpl, rKey.m_hImpl, keyName.pData, regFileName.pData, bWarnings, bReport); }
1258 
1260  { return m_pApi->dumpRegistry(m_hImpl, rKey.m_hImpl); }
1261 
1262 
1263 #endif
1264 
1265 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */