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
27void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
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
37void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
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
47sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
48{
49 ORegKey* pKey = static_cast< ORegKey* >(hKey);
50 return pKey != nullptr && pKey->isReadOnly();
51}
52
53RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
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);
63 return RegError::INVALID_KEY;
64 }
65}
66
67RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey,
68 rtl_uString* keyName,
69 RegKeyHandle* phNewKey)
70{
71 *phNewKey = nullptr;
72
73 ORegKey* pKey = static_cast< ORegKey* >(hKey);
74 if (!pKey)
75 return RegError::INVALID_KEY;
76
77 if (pKey->isDeleted())
78 return RegError::INVALID_KEY;
79
80 if (pKey->isReadOnly())
81 return RegError::REGISTRY_READONLY;
82
83 return pKey->createKey(OUString::unacquired(&keyName), phNewKey);
84}
85
86RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey,
87 rtl_uString* keyName,
88 RegKeyHandle* phOpenKey)
89{
90 *phOpenKey = nullptr;
91
92 ORegKey* pKey = static_cast< ORegKey* >(hKey);
93 if (!pKey)
94 return RegError::INVALID_KEY;
95
96 if (pKey->isDeleted())
97 return RegError::INVALID_KEY;
98
99 return pKey->openKey(OUString::unacquired(&keyName), phOpenKey);
100}
101
102RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey,
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)
112 return RegError::INVALID_KEY;
113
114 if (pKey->isDeleted())
115 return RegError::INVALID_KEY;
116
117 return pKey->openSubKeys(OUString::unacquired(&keyName), pphSubKeys, pnSubKeys);
118}
119
120RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle* phSubKeys,
121 sal_uInt32 nSubKeys)
122{
123 if (phSubKeys == nullptr || nSubKeys == 0)
124 return RegError::INVALID_KEY;
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
136RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey,
137 rtl_uString* keyName)
138{
139 ORegKey* pKey = static_cast< ORegKey* >(hKey);
140 if (!pKey)
141 return RegError::INVALID_KEY;
142
143 if (pKey->isDeleted())
144 return RegError::INVALID_KEY;
145
146 if (pKey->isReadOnly())
147 return RegError::REGISTRY_READONLY;
148
149 return pKey->deleteKey(OUString::unacquired(&keyName));
150}
151
152RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey)
153{
154 ORegKey* pKey = static_cast< ORegKey* >(hKey);
155 if (!pKey)
156 return RegError::INVALID_KEY;
157
158 return pKey->closeKey(hKey);
159}
160
161RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey,
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)
169 return RegError::INVALID_KEY;
170
171 if (pKey->isDeleted())
172 return RegError::INVALID_KEY;
173
174 if (pKey->isReadOnly())
175 return RegError::REGISTRY_READONLY;
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
201RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey,
202 rtl_uString* keyName,
203 sal_Int32 const * pValueList,
204 sal_uInt32 len)
205{
206 ORegKey* pKey = static_cast< ORegKey* >(hKey);
207 if (!pKey)
208 return RegError::INVALID_KEY;
209
210 if (pKey->isDeleted())
211 return RegError::INVALID_KEY;
212
213 if (pKey->isReadOnly())
214 return RegError::REGISTRY_READONLY;
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
240RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey,
241 rtl_uString* keyName,
242 char** pValueList,
243 sal_uInt32 len)
244{
245 ORegKey* pKey = static_cast< ORegKey* >(hKey);
246 if (!pKey)
247 return RegError::INVALID_KEY;
248
249 if (pKey->isDeleted())
250 return RegError::INVALID_KEY;
251
252 if (pKey->isReadOnly())
253 return RegError::REGISTRY_READONLY;
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
279RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey,
280 rtl_uString* keyName,
281 sal_Unicode** pValueList,
282 sal_uInt32 len)
283{
284 ORegKey* pKey = static_cast< ORegKey* >(hKey);
285 if (!pKey)
286 return RegError::INVALID_KEY;
287
288 if (pKey->isDeleted())
289 return RegError::INVALID_KEY;
290
291 if (pKey->isReadOnly())
292 return RegError::REGISTRY_READONLY;
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
318RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey,
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)
328 return RegError::INVALID_KEY;
329
330 if (pKey->isDeleted())
331 return RegError::INVALID_KEY;
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);
347 return RegError::INVALID_VALUE;
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 {
359 return RegError::INVALID_VALUE;
360 }
361
362 *pValueType = valueType;
363 *pValueSize = valueSize;
364
365 return RegError::NO_ERROR;
366}
367
368RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey,
369 rtl_uString* keyName,
370 RegValue pValue)
371{
372 ORegKey* pKey = static_cast< ORegKey* >(hKey);
373 if (!pKey)
374 return RegError::INVALID_KEY;
375
376 if (pKey->isDeleted())
377 return RegError::INVALID_KEY;
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
400RegError REGISTRY_CALLTYPE getLongListValue(RegKeyHandle hKey,
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)
411 return RegError::INVALID_KEY;
412
413 if (pKey->isDeleted())
414 return RegError::INVALID_KEY;
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
437RegError REGISTRY_CALLTYPE getStringListValue(RegKeyHandle hKey,
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)
448 return RegError::INVALID_KEY;
449
450 if (pKey->isDeleted())
451 return RegError::INVALID_KEY;
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
474RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey,
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)
485 return RegError::INVALID_KEY;
486
487 if (pKey->isDeleted())
488 return RegError::INVALID_KEY;
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
511RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType,
512 RegValue pValueList,
513 sal_uInt32 len)
514{
515 switch (valueType)
516 {
517 case RegValueType::LONGLIST:
518 {
519 std::free(pValueList);
520 }
521 break;
522 case RegValueType::STRINGLIST:
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:
545 return RegError::INVALID_VALUE;
546 }
547
548 pValueList = nullptr;
549 return RegError::NO_ERROR;
550}
551
552RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey,
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)
559 return RegError::INVALID_KEY;
560
561 if (pKey->isDeleted())
562 return RegError::INVALID_KEY;
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
571RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey,
572 rtl_uString* keyName,
573 rtl_uString*** pSubKeyNames,
574 sal_uInt32* pnSubKeys)
575{
576 ORegKey* pKey = static_cast< ORegKey* >(hKey);
577 if (!pKey)
578 return RegError::INVALID_KEY;
579
580 if (pKey->isDeleted())
581 return RegError::INVALID_KEY;
582
583 return pKey->getKeyNames(OUString::unacquired(&keyName), pSubKeyNames, pnSubKeys);
584}
585
586RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString** pKeyNames,
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
599RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey,
600 rtl_uString* keyName,
601 RegKeyHandle* phOpenKey)
602{
603 if (!hKey)
604 return RegError::INVALID_KEY;
605
606 return openKey(hKey, keyName, phOpenKey);
607}
608
609RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey)
610{
611 if (!hKey)
612 return RegError::INVALID_KEY;
613
614 return closeKey(hKey);
615}
616
617
618/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
ORegKey::createKey
RegError createKey(std::u16string_view keyName, RegKeyHandle *phNewKey)
Definition: keyimpl.cxx:57
ORegKey::setUnicodeListValue
RegError setUnicodeListValue(std::u16string_view valueName, sal_Unicode **pValueList, sal_uInt32 len)
Definition: keyimpl.cxx:423
ORegKey::getRegistry
ORegistry * getRegistry() const
Definition: keyimpl.hxx:116
ORegKey::getValueInfo
RegError getValueInfo(std::u16string_view valueName, RegValueType *pValueTye, sal_uInt32 *pValueSize) const
Definition: keyimpl.cxx:189
ORegKey::getValue
RegError getValue(std::u16string_view valueName, RegValue value) const
Definition: keyimpl.cxx:484
ORegKey::setLongListValue
RegError setLongListValue(std::u16string_view valueName, sal_Int32 const *pValueList, sal_uInt32 len)
Definition: keyimpl.cxx:309
ORegKey::releaseKey
RegError releaseKey(RegKeyHandle hKey)
Definition: keyimpl.cxx:52
ORegKey::getResolvedKeyName
RegError getResolvedKeyName(std::u16string_view keyName, OUString &resolvedName) const
Definition: keyimpl.cxx:849
ORegKey::getStringListValue
RegError getStringListValue(std::u16string_view valueName, char ***pValueList, sal_uInt32 *pLen) const
Definition: keyimpl.cxx:660
ORegKey::getKeyNames
RegError getKeyNames(std::u16string_view keyName, rtl_uString ***pSubKeyNames, sal_uInt32 *pnSubKeys)
Definition: keyimpl.cxx:125
ORegKey::isDeleted
bool isDeleted() const
Definition: keyimpl.hxx:99
ORegKey::getLongListValue
RegError getLongListValue(std::u16string_view valueName, sal_Int32 **pValueList, sal_uInt32 *pLen) const
Definition: keyimpl.cxx:560
ORegKey::getUnicodeListValue
RegError getUnicodeListValue(std::u16string_view valueName, sal_Unicode ***pValueList, sal_uInt32 *pLen) const
Definition: keyimpl.cxx:754
ORegKey::setValue
RegError setValue(std::u16string_view valueName, RegValueType vType, RegValue value, sal_uInt32 vSize)
Definition: keyimpl.cxx:241
ORegKey::openKey
RegError openKey(std::u16string_view keyName, RegKeyHandle *phOpenKey)
Definition: keyimpl.cxx:62
ORegKey::deleteKey
RegError deleteKey(std::u16string_view keyName)
Definition: keyimpl.cxx:184
ORegKey::openSubKeys
RegError openSubKeys(std::u16string_view keyName, RegKeyHandle **phOpenSubKeys, sal_uInt32 *pnSubKeys)
Definition: keyimpl.cxx:67
ORegKey::setStringListValue
RegError setStringListValue(std::u16string_view valueName, char **pValueList, sal_uInt32 len)
Definition: keyimpl.cxx:361
ORegKey::isReadOnly
bool isReadOnly() const
Definition: keyimpl.hxx:111
ORegKey::closeKey
RegError closeKey(RegKeyHandle hKey)
Definition: keyimpl.cxx:179
ORegKey::getName
const OUString & getName() const
Definition: keyimpl.hxx:124
ORegistry::closeKey
RegError closeKey(RegKeyHandle hKey)
Definition: regimpl.cxx:704
ORegistry::acquireKey
RegError acquireKey(RegKeyHandle hKey)
Definition: regimpl.cxx:575
ORegistry::releaseKey
RegError releaseKey(RegKeyHandle hKey)
Definition: regimpl.cxx:587
pData
std::unique_ptr< sal_Int32[]> pData
i
int i
setUnicodeListValue
RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey, rtl_uString *keyName, sal_Unicode **pValueList, sal_uInt32 len)
Definition: regkey.cxx:279
setLongListValue
RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey, rtl_uString *keyName, sal_Int32 const *pValueList, sal_uInt32 len)
Definition: regkey.cxx:201
createKey
RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey, rtl_uString *keyName, RegKeyHandle *phNewKey)
Definition: regkey.cxx:67
setStringListValue
RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey, rtl_uString *keyName, char **pValueList, sal_uInt32 len)
Definition: regkey.cxx:240
acquireKey
void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
Definition: regkey.cxx:27
getValueInfo
RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey, rtl_uString *keyName, RegValueType *pValueType, sal_uInt32 *pValueSize)
Definition: regkey.cxx:318
getStringListValue
RegError REGISTRY_CALLTYPE getStringListValue(RegKeyHandle hKey, rtl_uString *keyName, char ***pValueList, sal_uInt32 *pLen)
Definition: regkey.cxx:437
releaseKey
void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
Definition: regkey.cxx:37
getKeyNames
RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey, rtl_uString *keyName, rtl_uString ***pSubKeyNames, sal_uInt32 *pnSubKeys)
Definition: regkey.cxx:571
getLongListValue
RegError REGISTRY_CALLTYPE getLongListValue(RegKeyHandle hKey, rtl_uString *keyName, sal_Int32 **pValueList, sal_uInt32 *pLen)
Definition: regkey.cxx:400
getKeyName
RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString **pKeyName)
Definition: regkey.cxx:53
reg_openKey
RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey, rtl_uString *keyName, RegKeyHandle *phOpenKey)
This function opens the specified key.
Definition: regkey.cxx:599
deleteKey
RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey, rtl_uString *keyName)
Definition: regkey.cxx:136
getResolvedKeyName
RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey, rtl_uString *keyName, SAL_UNUSED_PARAMETER sal_Bool, rtl_uString **pResolvedName)
Definition: regkey.cxx:552
closeSubKeys
RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle *phSubKeys, sal_uInt32 nSubKeys)
Definition: regkey.cxx:120
freeKeyNames
RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString **pKeyNames, sal_uInt32 nKeys)
Definition: regkey.cxx:586
freeValueList
RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType, RegValue pValueList, sal_uInt32 len)
Definition: regkey.cxx:511
isKeyReadOnly
sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
Definition: regkey.cxx:47
openKey
RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey, rtl_uString *keyName, RegKeyHandle *phOpenKey)
Definition: regkey.cxx:86
openSubKeys
RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey, rtl_uString *keyName, RegKeyHandle **pphSubKeys, sal_uInt32 *pnSubKeys)
Definition: regkey.cxx:102
closeKey
RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey)
Definition: regkey.cxx:152
getValue
RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey, rtl_uString *keyName, RegValue pValue)
Definition: regkey.cxx:368
reg_closeKey
RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey)
This function closes the specified key.
Definition: regkey.cxx:609
getUnicodeListValue
RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey, rtl_uString *keyName, sal_Unicode ***pValueList, sal_uInt32 *pLen)
Definition: regkey.cxx:474
setValue
RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey, rtl_uString *keyName, RegValueType valueType, RegValue pData, sal_uInt32 valueSize)
Definition: regkey.cxx:161
STRINGLIST
STRINGLIST
The key has a value of type ascii string list.
Definition: regtype.h:75
RegKeyHandle
void * RegKeyHandle
defines the type of a registry key handle used in the C API.
Definition: regtype.h:29
INVALID_KEY
INVALID_KEY
the key is not in a valid state.
Definition: regtype.h:116
REGISTRY_READONLY
REGISTRY_READONLY
registry is open with readonly access rights.
Definition: regtype.h:91
NOT_DEFINED
NOT_DEFINED
The key has no value or the value type is unknown.
Definition: regtype.h:63
RegValueType
enum SAL_DLLPUBLIC_RTTI RegValueType
defines the type of a key value.
Definition: regtype.h:61
RegValue
void * RegValue
defines the type of a registry key value handle used in the C API.
Definition: regtype.h:32
REGISTRY_CALLTYPE
#define REGISTRY_CALLTYPE
specify the calling convention for the registry API
Definition: regtype.h:129
LONGLIST
LONGLIST
The key has a value of type long list.
Definition: regtype.h:73
NO_ERROR
NO_ERROR
no error.
Definition: regtype.h:84
RegError
enum SAL_DLLPUBLIC_RTTI RegError
specifies the possible error codes which can occur using the registry API.
Definition: regtype.h:82
sal_Bool
unsigned char sal_Bool
sal_Unicode
sal_uInt16 sal_Unicode
Generated on Sun Jul 30 2023 04:38:10 for LibreOffice Module registry (master) by doxygen 1.9.3