| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_registry.hxx" |
| |
| #include "regkey.hxx" |
| |
| #include <registry/registry.hxx> |
| #include <rtl/alloc.h> |
| #include "regimpl.hxx" |
| #include "keyimpl.hxx" |
| |
| using rtl::OUString; |
| |
| //********************************************************************* |
| // acquireKey |
| // |
| void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey) |
| { |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (pKey != 0) |
| { |
| ORegistry* pReg = pKey->getRegistry(); |
| (void) pReg->acquireKey(pKey); |
| } |
| } |
| |
| |
| //********************************************************************* |
| // releaseKey |
| // |
| void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey) |
| { |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (pKey != 0) |
| { |
| ORegistry* pReg = pKey->getRegistry(); |
| (void) pReg->releaseKey(pKey); |
| } |
| } |
| |
| |
| //********************************************************************* |
| // isKeyReadOnly |
| // |
| sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey) |
| { |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| return (pKey != 0) ? pKey->isReadOnly() : sal_False; |
| } |
| |
| |
| //********************************************************************* |
| // getKeyName |
| // |
| RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName) |
| { |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (pKey) |
| { |
| rtl_uString_assign( pKeyName, pKey->getName().pData ); |
| return REG_NO_ERROR; |
| } else |
| { |
| rtl_uString_new(pKeyName); |
| return REG_INVALID_KEY; |
| } |
| } |
| |
| |
| //********************************************************************* |
| // createKey |
| // |
| RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| RegKeyHandle* phNewKey) |
| { |
| *phNewKey = 0; |
| |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isReadOnly()) |
| return REG_REGISTRY_READONLY; |
| |
| return pKey->createKey(keyName, phNewKey); |
| } |
| |
| //********************************************************************* |
| // openKey |
| // |
| RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| RegKeyHandle* phOpenKey) |
| { |
| *phOpenKey = 0; |
| |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| return pKey->openKey(keyName, phOpenKey); |
| } |
| |
| //********************************************************************* |
| // openSubKeys |
| // |
| RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| RegKeyHandle** pphSubKeys, |
| sal_uInt32* pnSubKeys) |
| { |
| *pphSubKeys = NULL; |
| *pnSubKeys = 0; |
| |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| return pKey->openSubKeys(keyName, pphSubKeys, pnSubKeys); |
| } |
| |
| //********************************************************************* |
| // closeSubKeys |
| // |
| RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle* phSubKeys, |
| sal_uInt32 nSubKeys) |
| { |
| if (phSubKeys == 0 || nSubKeys == 0) |
| return REG_INVALID_KEY; |
| |
| ORegistry* pReg = ((ORegKey*)(phSubKeys[0]))->getRegistry(); |
| for (sal_uInt32 i = 0; i < nSubKeys; i++) |
| { |
| (void) pReg->closeKey(phSubKeys[i]); |
| } |
| rtl_freeMemory(phSubKeys); |
| |
| return REG_NO_ERROR; |
| } |
| |
| //********************************************************************* |
| // deleteKey |
| // |
| RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey, |
| rtl_uString* keyName) |
| { |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isReadOnly()) |
| return REG_REGISTRY_READONLY; |
| |
| return pKey->deleteKey(keyName); |
| } |
| |
| //********************************************************************* |
| // closeKey |
| // |
| RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey) |
| { |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| return pKey->closeKey(hKey); |
| } |
| |
| //********************************************************************* |
| // setValue |
| // |
| RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| RegValueType valueType, |
| RegValue pData, |
| sal_uInt32 valueSize) |
| { |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isReadOnly()) |
| return REG_REGISTRY_READONLY; |
| |
| OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); |
| if (keyName->length) |
| { |
| ORegKey* pSubKey = 0; |
| RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); |
| if (_ret1 != REG_NO_ERROR) |
| return _ret1; |
| |
| _ret1 = pSubKey->setValue(valueName, valueType, pData, valueSize); |
| if (_ret1 != REG_NO_ERROR) |
| { |
| RegError _ret2 = pKey->closeKey(pSubKey); |
| if (_ret2) |
| return _ret2; |
| else |
| return _ret1; |
| } |
| |
| return pKey->closeKey(pSubKey); |
| } |
| |
| return pKey->setValue(valueName, valueType, pData, valueSize); |
| } |
| |
| //********************************************************************* |
| // setLongValueList |
| // |
| RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| sal_Int32* pValueList, |
| sal_uInt32 len) |
| { |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isReadOnly()) |
| return REG_REGISTRY_READONLY; |
| |
| OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); |
| if (keyName->length) |
| { |
| ORegKey* pSubKey = 0; |
| RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); |
| if (_ret1 != REG_NO_ERROR) |
| return _ret1; |
| |
| _ret1 = pSubKey->setLongListValue(valueName, pValueList, len); |
| if (_ret1 != REG_NO_ERROR) |
| { |
| RegError _ret2 = pKey->closeKey(pSubKey); |
| if (_ret2 != REG_NO_ERROR) |
| return _ret2; |
| else |
| return _ret1; |
| } |
| |
| return pKey->closeKey(pSubKey); |
| } |
| |
| return pKey->setLongListValue(valueName, pValueList, len); |
| } |
| |
| //********************************************************************* |
| // setStringValueList |
| // |
| RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| sal_Char** pValueList, |
| sal_uInt32 len) |
| { |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isReadOnly()) |
| return REG_REGISTRY_READONLY; |
| |
| OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); |
| if (keyName->length) |
| { |
| ORegKey* pSubKey = 0; |
| RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); |
| if (_ret1 != REG_NO_ERROR) |
| return _ret1; |
| |
| _ret1 = pSubKey->setStringListValue(valueName, pValueList, len); |
| if (_ret1 != REG_NO_ERROR) |
| { |
| RegError _ret2 = pKey->closeKey(pSubKey); |
| if (_ret2 != REG_NO_ERROR) |
| return _ret2; |
| else |
| return _ret1; |
| } |
| |
| return pKey->closeKey(pSubKey); |
| } |
| |
| return pKey->setStringListValue(valueName, pValueList, len); |
| } |
| |
| //********************************************************************* |
| // setUnicodeValueList |
| // |
| RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| sal_Unicode** pValueList, |
| sal_uInt32 len) |
| { |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isReadOnly()) |
| return REG_REGISTRY_READONLY; |
| |
| OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); |
| if (keyName->length) |
| { |
| ORegKey* pSubKey = 0; |
| RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); |
| if (_ret1 != REG_NO_ERROR) |
| return _ret1; |
| |
| _ret1 = pSubKey->setUnicodeListValue(valueName, pValueList, len); |
| if (_ret1 != REG_NO_ERROR) |
| { |
| RegError _ret2 = pKey->closeKey(pSubKey); |
| if (_ret2 != REG_NO_ERROR) |
| return _ret2; |
| else |
| return _ret1; |
| } |
| |
| return pKey->closeKey(pSubKey); |
| } |
| |
| return pKey->setUnicodeListValue(valueName, pValueList, len); |
| } |
| |
| //********************************************************************* |
| // getValueInfo |
| // |
| RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| RegValueType* pValueType, |
| sal_uInt32* pValueSize) |
| { |
| *pValueType = RG_VALUETYPE_NOT_DEFINED; |
| *pValueSize = 0; |
| |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| RegValueType valueType; |
| sal_uInt32 valueSize; |
| |
| OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); |
| if (keyName->length) |
| { |
| ORegKey* pSubKey = 0; |
| RegError _ret = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); |
| if (_ret != REG_NO_ERROR) |
| return _ret; |
| |
| if (pSubKey->getValueInfo(valueName, &valueType, &valueSize) != REG_NO_ERROR) |
| { |
| (void) pKey->releaseKey(pSubKey); |
| return REG_INVALID_VALUE; |
| } |
| |
| *pValueType = valueType; |
| *pValueSize = valueSize; |
| |
| return pKey->releaseKey(pSubKey); |
| } |
| |
| |
| if (pKey->getValueInfo(valueName, &valueType, &valueSize) != REG_NO_ERROR) |
| { |
| return REG_INVALID_VALUE; |
| } |
| |
| *pValueType = valueType; |
| *pValueSize = valueSize; |
| |
| return REG_NO_ERROR; |
| } |
| |
| //********************************************************************* |
| // getValueInfo |
| // |
| RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| RegValue pValue) |
| { |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); |
| if (keyName->length) |
| { |
| ORegKey* pSubKey = 0; |
| RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); |
| if (_ret1 != REG_NO_ERROR) |
| return _ret1; |
| |
| _ret1 = pSubKey->getValue(valueName, pValue); |
| if (_ret1 != REG_NO_ERROR) |
| { |
| (void) pKey->releaseKey(pSubKey); |
| return _ret1; |
| } |
| |
| return pKey->releaseKey(pSubKey); |
| } |
| |
| return pKey->getValue(valueName, pValue); |
| } |
| |
| //********************************************************************* |
| // getLongValueList |
| // |
| RegError REGISTRY_CALLTYPE getLongListValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| sal_Int32** pValueList, |
| sal_uInt32* pLen) |
| { |
| OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getLongListValue(): invalid parameter"); |
| *pValueList = 0, *pLen = 0; |
| |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); |
| if (keyName->length) |
| { |
| ORegKey* pSubKey = 0; |
| RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); |
| if (_ret1 != REG_NO_ERROR) |
| return _ret1; |
| |
| _ret1 = pSubKey->getLongListValue(valueName, pValueList, pLen); |
| if (_ret1 != REG_NO_ERROR) |
| { |
| (void) pKey->releaseKey(pSubKey); |
| return _ret1; |
| } |
| |
| return pKey->releaseKey(pSubKey); |
| } |
| |
| return pKey->getLongListValue(valueName, pValueList, pLen); |
| } |
| |
| //********************************************************************* |
| // getStringValueList |
| // |
| RegError REGISTRY_CALLTYPE getStringListValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| sal_Char*** pValueList, |
| sal_uInt32* pLen) |
| { |
| OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getStringListValue(): invalid parameter"); |
| *pValueList = 0, *pLen = 0; |
| |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); |
| if (keyName->length) |
| { |
| ORegKey* pSubKey = 0; |
| RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); |
| if (_ret1 != REG_NO_ERROR) |
| return _ret1; |
| |
| _ret1 = pSubKey->getStringListValue(valueName, pValueList, pLen); |
| if (_ret1 != REG_NO_ERROR) |
| { |
| (void) pKey->releaseKey(pSubKey); |
| return _ret1; |
| } |
| |
| return pKey->releaseKey(pSubKey); |
| } |
| |
| return pKey->getStringListValue(valueName, pValueList, pLen); |
| } |
| |
| //********************************************************************* |
| // getUnicodeListValue |
| // |
| RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| sal_Unicode*** pValueList, |
| sal_uInt32* pLen) |
| { |
| OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getUnicodeListValue(): invalid parameter"); |
| *pValueList = 0, *pLen = 0; |
| |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") ); |
| if (keyName->length) |
| { |
| ORegKey* pSubKey = 0; |
| RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey); |
| if (_ret1 != REG_NO_ERROR) |
| return _ret1; |
| |
| _ret1 = pSubKey->getUnicodeListValue(valueName, pValueList, pLen); |
| if (_ret1 != REG_NO_ERROR) |
| { |
| (void) pKey->releaseKey(pSubKey); |
| return _ret1; |
| } |
| |
| return pKey->releaseKey(pSubKey); |
| } |
| |
| return pKey->getUnicodeListValue(valueName, pValueList, pLen); |
| } |
| |
| //********************************************************************* |
| // freeValueList |
| // |
| RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType, |
| RegValue pValueList, |
| sal_uInt32 len) |
| { |
| switch (valueType) |
| { |
| case 5: |
| { |
| rtl_freeMemory(pValueList); |
| } |
| break; |
| case 6: |
| { |
| sal_Char** pVList = (sal_Char**)pValueList; |
| for (sal_uInt32 i=0; i < len; i++) |
| { |
| rtl_freeMemory(pVList[i]); |
| } |
| |
| rtl_freeMemory(pVList); |
| } |
| break; |
| case 7: |
| { |
| sal_Unicode** pVList = (sal_Unicode**)pValueList; |
| for (sal_uInt32 i=0; i < len; i++) |
| { |
| rtl_freeMemory(pVList[i]); |
| } |
| |
| rtl_freeMemory(pVList); |
| } |
| break; |
| default: |
| return REG_INVALID_VALUE; |
| } |
| |
| pValueList = NULL; |
| return REG_NO_ERROR; |
| } |
| |
| //********************************************************************* |
| // createLink |
| // |
| RegError REGISTRY_CALLTYPE createLink(RegKeyHandle, rtl_uString*, rtl_uString*) |
| { |
| return REG_INVALID_LINK; // links are no longer supported |
| } |
| |
| //********************************************************************* |
| // deleteLink |
| // |
| RegError REGISTRY_CALLTYPE deleteLink(RegKeyHandle, rtl_uString*) |
| { |
| return REG_INVALID_LINK; // links are no longer supported |
| } |
| |
| //********************************************************************* |
| // getKeyType |
| // |
| RegError REGISTRY_CALLTYPE getKeyType(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| RegKeyType* pKeyType) |
| { |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| return pKey->getKeyType(keyName, pKeyType); |
| } |
| |
| //********************************************************************* |
| // getLinkTarget |
| // |
| RegError REGISTRY_CALLTYPE getLinkTarget( |
| RegKeyHandle, rtl_uString*, rtl_uString**) |
| { |
| return REG_INVALID_LINK; // links are no longer supported |
| } |
| |
| //********************************************************************* |
| // getName |
| // |
| RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| sal_Bool, |
| rtl_uString** pResolvedName) |
| { |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| OUString resolvedName; |
| RegError _ret = pKey->getResolvedKeyName(keyName, resolvedName); |
| if (_ret == REG_NO_ERROR) |
| rtl_uString_assign(pResolvedName, resolvedName.pData); |
| return _ret; |
| } |
| |
| //********************************************************************* |
| // getKeyNames |
| // |
| RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| rtl_uString*** pSubKeyNames, |
| sal_uInt32* pnSubKeys) |
| { |
| ORegKey* pKey = static_cast< ORegKey* >(hKey); |
| if (!pKey) |
| return REG_INVALID_KEY; |
| |
| if (pKey->isDeleted()) |
| return REG_INVALID_KEY; |
| |
| return pKey->getKeyNames(keyName, pSubKeyNames, pnSubKeys); |
| } |
| |
| //********************************************************************* |
| // freeKeyNames |
| // |
| RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString** pKeyNames, |
| sal_uInt32 nKeys) |
| { |
| for (sal_uInt32 i=0; i < nKeys; i++) |
| { |
| rtl_uString_release(pKeyNames[i]); |
| } |
| |
| rtl_freeMemory(pKeyNames); |
| |
| return REG_NO_ERROR; |
| } |
| |
| //********************************************************************* |
| // C API |
| // |
| |
| //********************************************************************* |
| // reg_createKey |
| // |
| RegError REGISTRY_CALLTYPE reg_createKey(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| RegKeyHandle* phNewKey) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return createKey(hKey, keyName, phNewKey); |
| } |
| |
| //********************************************************************* |
| // reg_openKey |
| // |
| RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| RegKeyHandle* phOpenKey) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return openKey(hKey, keyName, phOpenKey); |
| } |
| |
| //********************************************************************* |
| // reg_openSubKeys |
| // |
| RegError REGISTRY_CALLTYPE reg_openSubKeys(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| RegKeyHandle** pphSubKeys, |
| sal_uInt32* pnSubKeys) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return openSubKeys(hKey, keyName, pphSubKeys, pnSubKeys); |
| } |
| |
| //********************************************************************* |
| // reg_closeSubKeys |
| // |
| RegError REGISTRY_CALLTYPE reg_closeSubKeys(RegKeyHandle* pphSubKeys, |
| sal_uInt32 nSubKeys) |
| { |
| if (!pphSubKeys) |
| return REG_INVALID_KEY; |
| |
| return closeSubKeys(pphSubKeys, nSubKeys); |
| } |
| |
| //********************************************************************* |
| // reg_deleteKey |
| // |
| RegError REGISTRY_CALLTYPE reg_deleteKey(RegKeyHandle hKey, |
| rtl_uString* keyName) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return deleteKey(hKey, keyName); |
| } |
| |
| //********************************************************************* |
| // reg_closeKey |
| // |
| RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return closeKey(hKey); |
| } |
| |
| |
| //********************************************************************* |
| // reg_getKeyName |
| // |
| RegError REGISTRY_CALLTYPE reg_getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName) |
| { |
| if (hKey) |
| { |
| rtl_uString_assign( pKeyName, ((ORegKey*)hKey)->getName().pData ); |
| return REG_NO_ERROR; |
| } else |
| { |
| rtl_uString_new( pKeyName ); |
| return REG_INVALID_KEY; |
| } |
| } |
| |
| //********************************************************************* |
| // reg_setValue |
| // |
| RegError REGISTRY_CALLTYPE reg_setValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| RegValueType valueType, |
| RegValue pData, |
| sal_uInt32 valueSize) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return setValue(hKey, keyName, valueType, pData, valueSize); |
| } |
| |
| //********************************************************************* |
| // reg_setLongListValue |
| // |
| RegError REGISTRY_CALLTYPE reg_setLongListValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| sal_Int32* pValueList, |
| sal_uInt32 len) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return setLongListValue(hKey, keyName, pValueList, len); |
| } |
| |
| //********************************************************************* |
| // reg_setStringListValue |
| // |
| RegError REGISTRY_CALLTYPE reg_setStringListValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| sal_Char** pValueList, |
| sal_uInt32 len) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return setStringListValue(hKey, keyName, pValueList, len); |
| } |
| |
| //********************************************************************* |
| // reg_setUnicodeListValue |
| // |
| RegError REGISTRY_CALLTYPE reg_setUnicodeListValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| sal_Unicode** pValueList, |
| sal_uInt32 len) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return setUnicodeListValue(hKey, keyName, pValueList, len); |
| } |
| |
| //********************************************************************* |
| // reg_getValueInfo |
| // |
| RegError REGISTRY_CALLTYPE reg_getValueInfo(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| RegValueType* pValueType, |
| sal_uInt32* pValueSize) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return getValueInfo(hKey, keyName, pValueType, pValueSize); |
| } |
| |
| //********************************************************************* |
| // reg_getValueInfo |
| // |
| RegError REGISTRY_CALLTYPE reg_getValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| RegValue pData) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return getValue(hKey, keyName, pData); |
| } |
| |
| //********************************************************************* |
| // reg_getLongListValue |
| // |
| RegError REGISTRY_CALLTYPE reg_getLongListValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| sal_Int32** pValueList, |
| sal_uInt32* pLen) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return getLongListValue(hKey, keyName, pValueList, pLen); |
| } |
| |
| //********************************************************************* |
| // reg_getStringListValue |
| // |
| RegError REGISTRY_CALLTYPE reg_getStringListValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| sal_Char*** pValueList, |
| sal_uInt32* pLen) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return getStringListValue(hKey, keyName, pValueList, pLen); |
| } |
| |
| //********************************************************************* |
| // reg_getUnicodeListValue |
| // |
| RegError REGISTRY_CALLTYPE reg_getUnicodeListValue(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| sal_Unicode*** pValueList, |
| sal_uInt32* pLen) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return getUnicodeListValue(hKey, keyName, pValueList, pLen); |
| } |
| |
| //********************************************************************* |
| // reg_freeValueList |
| // |
| RegError REGISTRY_CALLTYPE reg_freeValueList(RegValueType valueType, |
| RegValue pValueList, |
| sal_uInt32 len) |
| { |
| if (pValueList) |
| return freeValueList(valueType, pValueList, len); |
| else |
| return REG_INVALID_VALUE; |
| } |
| |
| //********************************************************************* |
| // reg_createLink |
| // |
| RegError REGISTRY_CALLTYPE reg_createLink(RegKeyHandle hKey, |
| rtl_uString* linkName, |
| rtl_uString* linkTarget) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return createLink(hKey, linkName, linkTarget); |
| } |
| |
| //********************************************************************* |
| // reg_deleteLink |
| // |
| RegError REGISTRY_CALLTYPE reg_deleteLink(RegKeyHandle hKey, |
| rtl_uString* linkName) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return deleteLink(hKey, linkName); |
| } |
| |
| //********************************************************************* |
| // reg_getKeyType |
| // |
| RegError REGISTRY_CALLTYPE reg_getKeyType(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| RegKeyType* pKeyType) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return getKeyType(hKey, keyName, pKeyType); |
| } |
| |
| //********************************************************************* |
| // reg_getLinkTarget |
| // |
| RegError REGISTRY_CALLTYPE reg_getLinkTarget(RegKeyHandle hKey, |
| rtl_uString* linkName, |
| rtl_uString** pLinkTarget) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return getLinkTarget(hKey, linkName, pLinkTarget); |
| } |
| |
| //********************************************************************* |
| // reg_getResolvedKeyName |
| // |
| RegError REGISTRY_CALLTYPE reg_getResolvedKeyName(RegKeyHandle hKey, |
| rtl_uString* keyName, |
| sal_Bool firstLinkOnly, |
| rtl_uString** pResolvedName) |
| { |
| if (!hKey) |
| return REG_INVALID_KEY; |
| |
| return getResolvedKeyName(hKey, keyName, firstLinkOnly, pResolvedName); |
| } |
