LibreOffice Module registry (master) 1
regkey.cxx
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
21#include "regkey.hxx"
22
23#include <osl/diagnose.h>
24#include "regimpl.hxx"
25#include "keyimpl.hxx"
26
28{
29 ORegKey* pKey = static_cast< ORegKey* >(hKey);
30 if (pKey != nullptr)
31 {
32 ORegistry* pReg = pKey->getRegistry();
33 (void) pReg->acquireKey(pKey);
34 }
35}
36
38{
39 ORegKey* pKey = static_cast< ORegKey* >(hKey);
40 if (pKey != nullptr)
41 {
42 ORegistry* pReg = pKey->getRegistry();
43 (void) pReg->releaseKey(pKey);
44 }
45}
46
48{
49 ORegKey* pKey = static_cast< ORegKey* >(hKey);
50 return pKey != nullptr && pKey->isReadOnly();
51}
52
54{
55 ORegKey* pKey = static_cast< ORegKey* >(hKey);
56 if (pKey)
57 {
58 rtl_uString_assign( pKeyName, pKey->getName().pData );
59 return RegError::NO_ERROR;
60 } else
61 {
62 rtl_uString_new(pKeyName);
64 }
65}
66
68 rtl_uString* keyName,
69 RegKeyHandle* phNewKey)
70{
71 *phNewKey = nullptr;
72
73 ORegKey* pKey = static_cast< ORegKey* >(hKey);
74 if (!pKey)
76
77 if (pKey->isDeleted())
79
80 if (pKey->isReadOnly())
82
83 return pKey->createKey(OUString::unacquired(&keyName), phNewKey);
84}
85
87 rtl_uString* keyName,
88 RegKeyHandle* phOpenKey)
89{
90 *phOpenKey = nullptr;
91
92 ORegKey* pKey = static_cast< ORegKey* >(hKey);
93 if (!pKey)
95
96 if (pKey->isDeleted())
98
99 return pKey->openKey(OUString::unacquired(&keyName), phOpenKey);
100}
101
103 rtl_uString* keyName,
104 RegKeyHandle** pphSubKeys,
105 sal_uInt32* pnSubKeys)
106{
107 *pphSubKeys = nullptr;
108 *pnSubKeys = 0;
109
110 ORegKey* pKey = static_cast< ORegKey* >(hKey);
111 if (!pKey)
113
114 if (pKey->isDeleted())
116
117 return pKey->openSubKeys(OUString::unacquired(&keyName), pphSubKeys, pnSubKeys);
118}
119
121 sal_uInt32 nSubKeys)
122{
123 if (phSubKeys == nullptr || nSubKeys == 0)
125
126 ORegistry* pReg = static_cast<ORegKey*>(phSubKeys[0])->getRegistry();
127 for (sal_uInt32 i = 0; i < nSubKeys; i++)
128 {
129 (void) pReg->closeKey(phSubKeys[i]);
130 }
131 std::free(phSubKeys);
132
133 return RegError::NO_ERROR;
134}
135
137 rtl_uString* keyName)
138{
139 ORegKey* pKey = static_cast< ORegKey* >(hKey);
140 if (!pKey)
142
143 if (pKey->isDeleted())
145
146 if (pKey->isReadOnly())
148
149 return pKey->deleteKey(OUString::unacquired(&keyName));
150}
151
153{
154 ORegKey* pKey = static_cast< ORegKey* >(hKey);
155 if (!pKey)
157
158 return pKey->closeKey(hKey);
159}
160
162 rtl_uString* keyName,
163 RegValueType valueType,
164 RegValue pData,
165 sal_uInt32 valueSize)
166{
167 ORegKey* pKey = static_cast< ORegKey* >(hKey);
168 if (!pKey)
170
171 if (pKey->isDeleted())
173
174 if (pKey->isReadOnly())
176
177 OUString valueName("value");
178 if (keyName->length)
179 {
180 ORegKey* pSubKey = nullptr;
181 RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
182 if (_ret1 != RegError::NO_ERROR)
183 return _ret1;
184
185 _ret1 = pSubKey->setValue(valueName, valueType, pData, valueSize);
186 if (_ret1 != RegError::NO_ERROR)
187 {
188 RegError _ret2 = pKey->closeKey(pSubKey);
189 if (_ret2 != RegError::NO_ERROR)
190 return _ret2;
191 else
192 return _ret1;
193 }
194
195 return pKey->closeKey(pSubKey);
196 }
197
198 return pKey->setValue(valueName, valueType, pData, valueSize);
199}
200
202 rtl_uString* keyName,
203 sal_Int32 const * pValueList,
204 sal_uInt32 len)
205{
206 ORegKey* pKey = static_cast< ORegKey* >(hKey);
207 if (!pKey)
209
210 if (pKey->isDeleted())
212
213 if (pKey->isReadOnly())
215
216 OUString valueName("value");
217 if (keyName->length)
218 {
219 ORegKey* pSubKey = nullptr;
220 RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
221 if (_ret1 != RegError::NO_ERROR)
222 return _ret1;
223
224 _ret1 = pSubKey->setLongListValue(valueName, pValueList, len);
225 if (_ret1 != RegError::NO_ERROR)
226 {
227 RegError _ret2 = pKey->closeKey(pSubKey);
228 if (_ret2 != RegError::NO_ERROR)
229 return _ret2;
230 else
231 return _ret1;
232 }
233
234 return pKey->closeKey(pSubKey);
235 }
236
237 return pKey->setLongListValue(valueName, pValueList, len);
238}
239
241 rtl_uString* keyName,
242 char** pValueList,
243 sal_uInt32 len)
244{
245 ORegKey* pKey = static_cast< ORegKey* >(hKey);
246 if (!pKey)
248
249 if (pKey->isDeleted())
251
252 if (pKey->isReadOnly())
254
255 OUString valueName("value");
256 if (keyName->length)
257 {
258 ORegKey* pSubKey = nullptr;
259 RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
260 if (_ret1 != RegError::NO_ERROR)
261 return _ret1;
262
263 _ret1 = pSubKey->setStringListValue(valueName, pValueList, len);
264 if (_ret1 != RegError::NO_ERROR)
265 {
266 RegError _ret2 = pKey->closeKey(pSubKey);
267 if (_ret2 != RegError::NO_ERROR)
268 return _ret2;
269 else
270 return _ret1;
271 }
272
273 return pKey->closeKey(pSubKey);
274 }
275
276 return pKey->setStringListValue(valueName, pValueList, len);
277}
278
280 rtl_uString* keyName,
281 sal_Unicode** pValueList,
282 sal_uInt32 len)
283{
284 ORegKey* pKey = static_cast< ORegKey* >(hKey);
285 if (!pKey)
287
288 if (pKey->isDeleted())
290
291 if (pKey->isReadOnly())
293
294 OUString valueName("value");
295 if (keyName->length)
296 {
297 ORegKey* pSubKey = nullptr;
298 RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
299 if (_ret1 != RegError::NO_ERROR)
300 return _ret1;
301
302 _ret1 = pSubKey->setUnicodeListValue(valueName, pValueList, len);
303 if (_ret1 != RegError::NO_ERROR)
304 {
305 RegError _ret2 = pKey->closeKey(pSubKey);
306 if (_ret2 != RegError::NO_ERROR)
307 return _ret2;
308 else
309 return _ret1;
310 }
311
312 return pKey->closeKey(pSubKey);
313 }
314
315 return pKey->setUnicodeListValue(valueName, pValueList, len);
316}
317
319 rtl_uString* keyName,
320 RegValueType* pValueType,
321 sal_uInt32* pValueSize)
322{
323 *pValueType = RegValueType::NOT_DEFINED;
324 *pValueSize = 0;
325
326 ORegKey* pKey = static_cast< ORegKey* >(hKey);
327 if (!pKey)
329
330 if (pKey->isDeleted())
332
333 RegValueType valueType;
334 sal_uInt32 valueSize;
335
336 OUString valueName("value");
337 if (keyName->length)
338 {
339 ORegKey* pSubKey = nullptr;
340 RegError _ret = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
341 if (_ret != RegError::NO_ERROR)
342 return _ret;
343
344 if (pSubKey->getValueInfo(valueName, &valueType, &valueSize) != RegError::NO_ERROR)
345 {
346 (void) pKey->releaseKey(pSubKey);
348 }
349
350 *pValueType = valueType;
351 *pValueSize = valueSize;
352
353 return pKey->releaseKey(pSubKey);
354 }
355
356
357 if (pKey->getValueInfo(valueName, &valueType, &valueSize) != RegError::NO_ERROR)
358 {
360 }
361
362 *pValueType = valueType;
363 *pValueSize = valueSize;
364
365 return RegError::NO_ERROR;
366}
367
369 rtl_uString* keyName,
370 RegValue pValue)
371{
372 ORegKey* pKey = static_cast< ORegKey* >(hKey);
373 if (!pKey)
375
376 if (pKey->isDeleted())
378
379 OUString valueName("value");
380 if (keyName->length)
381 {
382 ORegKey* pSubKey = nullptr;
383 RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
384 if (_ret1 != RegError::NO_ERROR)
385 return _ret1;
386
387 _ret1 = pSubKey->getValue(valueName, pValue);
388 if (_ret1 != RegError::NO_ERROR)
389 {
390 (void) pKey->releaseKey(pSubKey);
391 return _ret1;
392 }
393
394 return pKey->releaseKey(pSubKey);
395 }
396
397 return pKey->getValue(valueName, pValue);
398}
399
401 rtl_uString* keyName,
402 sal_Int32** pValueList,
403 sal_uInt32* pLen)
404{
405 assert((pValueList != nullptr) && (pLen != nullptr) && "registry::getLongListValue(): invalid parameter");
406 *pValueList = nullptr;
407 *pLen = 0;
408
409 ORegKey* pKey = static_cast< ORegKey* >(hKey);
410 if (!pKey)
412
413 if (pKey->isDeleted())
415
416 OUString valueName("value");
417 if (keyName->length)
418 {
419 ORegKey* pSubKey = nullptr;
420 RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
421 if (_ret1 != RegError::NO_ERROR)
422 return _ret1;
423
424 _ret1 = pSubKey->getLongListValue(valueName, pValueList, pLen);
425 if (_ret1 != RegError::NO_ERROR)
426 {
427 (void) pKey->releaseKey(pSubKey);
428 return _ret1;
429 }
430
431 return pKey->releaseKey(pSubKey);
432 }
433
434 return pKey->getLongListValue(valueName, pValueList, pLen);
435}
436
438 rtl_uString* keyName,
439 char*** pValueList,
440 sal_uInt32* pLen)
441{
442 OSL_PRECOND((pValueList != nullptr) && (pLen != nullptr), "registry::getStringListValue(): invalid parameter");
443 *pValueList = nullptr;
444 *pLen = 0;
445
446 ORegKey* pKey = static_cast< ORegKey* >(hKey);
447 if (!pKey)
449
450 if (pKey->isDeleted())
452
453 OUString valueName("value");
454 if (keyName->length)
455 {
456 ORegKey* pSubKey = nullptr;
457 RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
458 if (_ret1 != RegError::NO_ERROR)
459 return _ret1;
460
461 _ret1 = pSubKey->getStringListValue(valueName, pValueList, pLen);
462 if (_ret1 != RegError::NO_ERROR)
463 {
464 (void) pKey->releaseKey(pSubKey);
465 return _ret1;
466 }
467
468 return pKey->releaseKey(pSubKey);
469 }
470
471 return pKey->getStringListValue(valueName, pValueList, pLen);
472}
473
475 rtl_uString* keyName,
476 sal_Unicode*** pValueList,
477 sal_uInt32* pLen)
478{
479 assert((pValueList != nullptr) && (pLen != nullptr) && "registry::getUnicodeListValue(): invalid parameter");
480 *pValueList = nullptr;
481 *pLen = 0;
482
483 ORegKey* pKey = static_cast< ORegKey* >(hKey);
484 if (!pKey)
486
487 if (pKey->isDeleted())
489
490 OUString valueName("value");
491 if (keyName->length)
492 {
493 ORegKey* pSubKey = nullptr;
494 RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
495 if (_ret1 != RegError::NO_ERROR)
496 return _ret1;
497
498 _ret1 = pSubKey->getUnicodeListValue(valueName, pValueList, pLen);
499 if (_ret1 != RegError::NO_ERROR)
500 {
501 (void) pKey->releaseKey(pSubKey);
502 return _ret1;
503 }
504
505 return pKey->releaseKey(pSubKey);
506 }
507
508 return pKey->getUnicodeListValue(valueName, pValueList, pLen);
509}
510
512 RegValue pValueList,
513 sal_uInt32 len)
514{
515 switch (valueType)
516 {
518 {
519 std::free(pValueList);
520 }
521 break;
523 {
524 char** pVList = static_cast<char**>(pValueList);
525 for (sal_uInt32 i=0; i < len; i++)
526 {
527 std::free(pVList[i]);
528 }
529
530 std::free(pVList);
531 }
532 break;
533 case RegValueType::UNICODELIST:
534 {
535 sal_Unicode** pVList = static_cast<sal_Unicode**>(pValueList);
536 for (sal_uInt32 i=0; i < len; i++)
537 {
538 std::free(pVList[i]);
539 }
540
541 std::free(pVList);
542 }
543 break;
544 default:
546 }
547
548 pValueList = nullptr;
549 return RegError::NO_ERROR;
550}
551
553 rtl_uString* keyName,
554 SAL_UNUSED_PARAMETER sal_Bool,
555 rtl_uString** pResolvedName)
556{
557 ORegKey* pKey = static_cast< ORegKey* >(hKey);
558 if (!pKey)
560
561 if (pKey->isDeleted())
563
564 OUString resolvedName;
565 RegError _ret = pKey->getResolvedKeyName(OUString::unacquired(&keyName), resolvedName);
566 if (_ret == RegError::NO_ERROR)
567 rtl_uString_assign(pResolvedName, resolvedName.pData);
568 return _ret;
569}
570
572 rtl_uString* keyName,
573 rtl_uString*** pSubKeyNames,
574 sal_uInt32* pnSubKeys)
575{
576 ORegKey* pKey = static_cast< ORegKey* >(hKey);
577 if (!pKey)
579
580 if (pKey->isDeleted())
582
583 return pKey->getKeyNames(OUString::unacquired(&keyName), pSubKeyNames, pnSubKeys);
584}
585
587 sal_uInt32 nKeys)
588{
589 for (sal_uInt32 i=0; i < nKeys; i++)
590 {
591 rtl_uString_release(pKeyNames[i]);
592 }
593
594 std::free(pKeyNames);
595
596 return RegError::NO_ERROR;
597}
598
600 rtl_uString* keyName,
601 RegKeyHandle* phOpenKey)
602{
603 if (!hKey)
605
606 return openKey(hKey, keyName, phOpenKey);
607}
608
610{
611 if (!hKey)
613
614 return closeKey(hKey);
615}
616
617
618/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
RegError createKey(std::u16string_view keyName, RegKeyHandle *phNewKey)
Definition: keyimpl.cxx:56
RegError setUnicodeListValue(std::u16string_view valueName, sal_Unicode **pValueList, sal_uInt32 len)
Definition: keyimpl.cxx:422
ORegistry * getRegistry() const
Definition: keyimpl.hxx:116
RegError getValueInfo(std::u16string_view valueName, RegValueType *pValueTye, sal_uInt32 *pValueSize) const
Definition: keyimpl.cxx:188
RegError getValue(std::u16string_view valueName, RegValue value) const
Definition: keyimpl.cxx:483
RegError setLongListValue(std::u16string_view valueName, sal_Int32 const *pValueList, sal_uInt32 len)
Definition: keyimpl.cxx:308
RegError releaseKey(RegKeyHandle hKey)
Definition: keyimpl.cxx:51
RegError getResolvedKeyName(std::u16string_view keyName, OUString &resolvedName) const
Definition: keyimpl.cxx:848
RegError getStringListValue(std::u16string_view valueName, char ***pValueList, sal_uInt32 *pLen) const
Definition: keyimpl.cxx:659
RegError getKeyNames(std::u16string_view keyName, rtl_uString ***pSubKeyNames, sal_uInt32 *pnSubKeys)
Definition: keyimpl.cxx:124
bool isDeleted() const
Definition: keyimpl.hxx:99
RegError getLongListValue(std::u16string_view valueName, sal_Int32 **pValueList, sal_uInt32 *pLen) const
Definition: keyimpl.cxx:559
RegError getUnicodeListValue(std::u16string_view valueName, sal_Unicode ***pValueList, sal_uInt32 *pLen) const
Definition: keyimpl.cxx:753
RegError setValue(std::u16string_view valueName, RegValueType vType, RegValue value, sal_uInt32 vSize)
Definition: keyimpl.cxx:240
RegError openKey(std::u16string_view keyName, RegKeyHandle *phOpenKey)
Definition: keyimpl.cxx:61
RegError deleteKey(std::u16string_view keyName)
Definition: keyimpl.cxx:183
RegError openSubKeys(std::u16string_view keyName, RegKeyHandle **phOpenSubKeys, sal_uInt32 *pnSubKeys)
Definition: keyimpl.cxx:66
RegError setStringListValue(std::u16string_view valueName, char **pValueList, sal_uInt32 len)
Definition: keyimpl.cxx:360
bool isReadOnly() const
Definition: keyimpl.hxx:111
RegError closeKey(RegKeyHandle hKey)
Definition: keyimpl.cxx:178
const OUString & getName() const
Definition: keyimpl.hxx:124
RegError closeKey(RegKeyHandle hKey)
Definition: regimpl.cxx:704
RegError acquireKey(RegKeyHandle hKey)
Definition: regimpl.cxx:575
RegError releaseKey(RegKeyHandle hKey)
Definition: regimpl.cxx:587
std::unique_ptr< sal_Int32[]> pData
int i
RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey, rtl_uString *keyName, sal_Unicode **pValueList, sal_uInt32 len)
Definition: regkey.cxx:279
RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey, rtl_uString *keyName, sal_Int32 const *pValueList, sal_uInt32 len)
Definition: regkey.cxx:201
RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey, rtl_uString *keyName, RegKeyHandle *phNewKey)
Definition: regkey.cxx:67
RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey, rtl_uString *keyName, char **pValueList, sal_uInt32 len)
Definition: regkey.cxx:240
void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
Definition: regkey.cxx:27
RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey, rtl_uString *keyName, RegValueType *pValueType, sal_uInt32 *pValueSize)
Definition: regkey.cxx:318
RegError REGISTRY_CALLTYPE getStringListValue(RegKeyHandle hKey, rtl_uString *keyName, char ***pValueList, sal_uInt32 *pLen)
Definition: regkey.cxx:437
void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
Definition: regkey.cxx:37
RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey, rtl_uString *keyName, rtl_uString ***pSubKeyNames, sal_uInt32 *pnSubKeys)
Definition: regkey.cxx:571
RegError REGISTRY_CALLTYPE getLongListValue(RegKeyHandle hKey, rtl_uString *keyName, sal_Int32 **pValueList, sal_uInt32 *pLen)
Definition: regkey.cxx:400
RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString **pKeyName)
Definition: regkey.cxx:53
RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey, rtl_uString *keyName, RegKeyHandle *phOpenKey)
This function opens the specified key.
Definition: regkey.cxx:599
RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey, rtl_uString *keyName)
Definition: regkey.cxx:136
RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey, rtl_uString *keyName, SAL_UNUSED_PARAMETER sal_Bool, rtl_uString **pResolvedName)
Definition: regkey.cxx:552
RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle *phSubKeys, sal_uInt32 nSubKeys)
Definition: regkey.cxx:120
RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString **pKeyNames, sal_uInt32 nKeys)
Definition: regkey.cxx:586
RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType, RegValue pValueList, sal_uInt32 len)
Definition: regkey.cxx:511
sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
Definition: regkey.cxx:47
RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey, rtl_uString *keyName, RegKeyHandle *phOpenKey)
Definition: regkey.cxx:86
RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey, rtl_uString *keyName, RegKeyHandle **pphSubKeys, sal_uInt32 *pnSubKeys)
Definition: regkey.cxx:102
RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey)
Definition: regkey.cxx:152
RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey, rtl_uString *keyName, RegValue pValue)
Definition: regkey.cxx:368
RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey)
This function closes the specified key.
Definition: regkey.cxx:609
RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey, rtl_uString *keyName, sal_Unicode ***pValueList, sal_uInt32 *pLen)
Definition: regkey.cxx:474
RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey, rtl_uString *keyName, RegValueType valueType, RegValue pData, sal_uInt32 valueSize)
Definition: regkey.cxx:161
STRINGLIST
The key has a value of type ascii string list.
Definition: regtype.h:76
INVALID_VALUE
the key has an invalid value or the value type is unknown.
Definition: regtype.h:126
void * RegKeyHandle
defines the type of a registry key handle used in the C API.
Definition: regtype.h:30
INVALID_KEY
the key is not in a valid state.
Definition: regtype.h:117
REGISTRY_READONLY
registry is open with readonly access rights.
Definition: regtype.h:92
NOT_DEFINED
The key has no value or the value type is unknown.
Definition: regtype.h:64
enum SAL_DLLPUBLIC_RTTI RegValueType
defines the type of a key value.
Definition: regtype.h:62
void * RegValue
defines the type of a registry key value handle used in the C API.
Definition: regtype.h:33
#define REGISTRY_CALLTYPE
specify the calling convention for the registry API
Definition: regtype.h:137
LONGLIST
The key has a value of type long list.
Definition: regtype.h:74
NO_ERROR
no error.
Definition: regtype.h:85
enum SAL_DLLPUBLIC_RTTI RegError
specifies the possible error codes which can occur using the registry API.
Definition: regtype.h:83
unsigned char sal_Bool
sal_uInt16 sal_Unicode