convert RegValueType to scoped enum

Change-Id: Ic672e75db4d7323760577b19490ffa28d38965b6

7 files changed, 130 insertions, 130 deletions

diff --git a/registry/source/keyimpl.cxx b/registry/source/keyimpl.cxx
index 4f1a4f4aa585..1dcb797867b5 100644
--- a/registry/source/keyimpl.cxx
+++ b/registry/source/keyimpl.cxx
@@ -238,7 +238,7 @@ RegError ORegKey::getValueInfo(const OUString& valueName, RegValueType* pValueTy
 
     if ( rValue.create(m_pRegistry->getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, accessMode) )
     {
-        *pValueType = RG_VALUETYPE_NOT_DEFINED;
+        *pValueType = RegValueType::NOT_DEFINED;
         *pValueSize = 0;
         return REG_VALUE_NOT_EXISTS;
     }
@@ -262,12 +262,12 @@ RegError ORegKey::getValueInfo(const OUString& valueName, RegValueType* pValueTy
     readUINT32(pBuffer+VALUE_TYPEOFFSET, size);
 
     *pValueType = (RegValueType)type;
-//    if (*pValueType == RG_VALUETYPE_UNICODE)
+//    if (*pValueType == RegValueType::UNICODE)
 //    {
 //        *pValueSize = (size / 2) * sizeof(sal_Unicode);
 //    } else
 //    {
-        if (*pValueType > 4)
+        if (*pValueType > RegValueType::BINARY)
         {
             rtl_freeMemory(pBuffer);
             pBuffer = static_cast<sal_uInt8*>(rtl_allocateMemory(4));
@@ -297,7 +297,7 @@ RegError ORegKey::setValue(const OUString& valueName, RegValueType vType, RegVal
         return REG_REGISTRY_READONLY;
     }
 
-    if (vType > 4)
+    if (vType > RegValueType::BINARY)
     {
         return REG_INVALID_VALUE;
     }
@@ -322,19 +322,19 @@ RegError ORegKey::setValue(const OUString& valueName, RegValueType vType, RegVal
 
     switch (vType)
     {
-        case RG_VALUETYPE_NOT_DEFINED:
+        case RegValueType::NOT_DEFINED:
             memcpy(pBuffer+VALUE_HEADEROFFSET, value, size);
             break;
-        case RG_VALUETYPE_LONG:
+        case RegValueType::LONG:
             writeINT32(pBuffer+VALUE_HEADEROFFSET, *static_cast<sal_Int32*>(value));
             break;
-        case RG_VALUETYPE_STRING:
+        case RegValueType::STRING:
             writeUtf8(pBuffer+VALUE_HEADEROFFSET, static_cast<const sal_Char*>(value));
             break;
-        case RG_VALUETYPE_UNICODE:
+        case RegValueType::UNICODE:
             writeString(pBuffer+VALUE_HEADEROFFSET, static_cast<const sal_Unicode*>(value));
             break;
-        case RG_VALUETYPE_BINARY:
+        case RegValueType::BINARY:
             memcpy(pBuffer+VALUE_HEADEROFFSET, value, size);
             break;
         default:
@@ -386,7 +386,7 @@ RegError ORegKey::setLongListValue(const OUString& valueName, sal_Int32* pValueL
 
     size += len * 4;
 
-    sal_uInt8 type = (sal_uInt8)RG_VALUETYPE_LONGLIST;
+    sal_uInt8 type = (sal_uInt8)RegValueType::LONGLIST;
     pBuffer = static_cast<sal_uInt8*>(rtl_allocateMemory(VALUE_HEADERSIZE + size));
     memcpy(pBuffer, &type, 1);
 
@@ -449,7 +449,7 @@ RegError ORegKey::setStringListValue(const OUString& valueName, sal_Char** pValu
         size +=  4 + strlen(pValueList[i]) + 1;
     }
 
-    sal_uInt8 type = (sal_uInt8)RG_VALUETYPE_STRINGLIST;
+    sal_uInt8 type = (sal_uInt8)RegValueType::STRINGLIST;
     pBuffer = static_cast<sal_uInt8*>(rtl_allocateMemory(VALUE_HEADERSIZE + size));
     memcpy(pBuffer, &type, 1);
 
@@ -517,7 +517,7 @@ RegError ORegKey::setUnicodeListValue(const OUString& valueName, sal_Unicode** p
         size +=  4 + ((rtl_ustr_getLength(pValueList[i]) +1) * 2);
     }
 
-    sal_uInt8 type = (sal_uInt8)RG_VALUETYPE_UNICODELIST;
+    sal_uInt8 type = (sal_uInt8)RegValueType::UNICODELIST;
     pBuffer = static_cast<sal_uInt8*>(rtl_allocateMemory(VALUE_HEADERSIZE + size));
     memcpy(pBuffer, &type, 1);
 
@@ -600,7 +600,7 @@ RegError ORegKey::getValue(const OUString& valueName, RegValue value) const
 
     rtl_freeMemory(pBuffer);
 
-    if (valueType > 4)
+    if (valueType > RegValueType::BINARY)
     {
         return REG_INVALID_VALUE;
     }
@@ -620,25 +620,25 @@ RegError ORegKey::getValue(const OUString& valueName, RegValue value) const
 
     switch (valueType)
     {
-        case RG_VALUETYPE_NOT_DEFINED:
+        case RegValueType::NOT_DEFINED:
             memcpy(value, pBuffer, valueSize);
             break;
-        case RG_VALUETYPE_LONG:
+        case RegValueType::LONG:
             readINT32(pBuffer, *static_cast<sal_Int32*>(value));
             break;
-        case RG_VALUETYPE_STRING:
+        case RegValueType::STRING:
             readUtf8(pBuffer, static_cast<sal_Char*>(value), valueSize);
             break;
-        case RG_VALUETYPE_UNICODE:
+        case RegValueType::UNICODE:
             readString(pBuffer, static_cast<sal_Unicode*>(value), valueSize);
             break;
-        case RG_VALUETYPE_BINARY:
+        case RegValueType::BINARY:
             memcpy(value, pBuffer, valueSize);
             break;
         // coverity[dead_error_begin] - following conditions exist to avoid compiler warning
-        case RG_VALUETYPE_LONGLIST:
-        case RG_VALUETYPE_STRINGLIST:
-        case RG_VALUETYPE_UNICODELIST:
+        case RegValueType::LONGLIST:
+        case RegValueType::STRINGLIST:
+        case RegValueType::UNICODELIST:
             memcpy(value, pBuffer, valueSize);
             break;
     }
@@ -697,7 +697,7 @@ RegError ORegKey::getLongListValue(const OUString& valueName, sal_Int32** pValue
     sal_uInt8   type = *((sal_uInt8*)pBuffer);
     valueType = (RegValueType)type;
 
-    if (valueType != RG_VALUETYPE_LONGLIST)
+    if (valueType != RegValueType::LONGLIST)
     {
         pValueList = NULL;
         *pLen = 0;
@@ -811,7 +811,7 @@ RegError ORegKey::getStringListValue(const OUString& valueName, sal_Char*** pVal
     sal_uInt8   type = *((sal_uInt8*)pBuffer);
     valueType = (RegValueType)type;
 
-    if (valueType != RG_VALUETYPE_STRINGLIST)
+    if (valueType != RegValueType::STRINGLIST)
     {
         pValueList = NULL;
         *pLen = 0;
@@ -917,7 +917,7 @@ RegError ORegKey::getUnicodeListValue(const OUString& valueName, sal_Unicode***
     sal_uInt8   type = *((sal_uInt8*)pBuffer);
     valueType = (RegValueType)type;
 
-    if (valueType != RG_VALUETYPE_UNICODELIST)
+    if (valueType != RegValueType::UNICODELIST)
     {
         pValueList = NULL;
         *pLen = 0;
diff --git a/registry/source/regimpl.cxx b/registry/source/regimpl.cxx
index 876245a0d366..0a7ad76f52a5 100644
--- a/registry/source/regimpl.cxx
+++ b/registry/source/regimpl.cxx
@@ -1078,7 +1078,7 @@ RegError ORegistry::loadAndSaveValue(ORegKey* pTargetKey,
 
     if (!rValue.create(rTargetFile, sTargetPath, valueName, VALUE_MODE_OPEN))
     {
-        if (valueType == RG_VALUETYPE_BINARY)
+        if (valueType == RegValueType::BINARY)
         {
             _ret = checkBlop(
                 rValue, sTargetPath, valueSize, pBuffer+VALUE_HEADEROFFSET,
@@ -1153,7 +1153,7 @@ RegError ORegistry::checkBlop(OStoreStream& rValue,
         readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize);
         rtl_freeMemory(pBuffer);
 
-        if (valueType == RG_VALUETYPE_BINARY)
+        if (valueType == RegValueType::BINARY)
         {
             pBuffer = static_cast<sal_uInt8*>(rtl_allocateMemory(valueSize));
             if (!rValue.readAt(VALUE_HEADEROFFSET, pBuffer, valueSize, rwBytes) &&
@@ -1303,7 +1303,7 @@ RegError ORegistry::mergeModuleValue(OStoreStream& rTargetValue,
         const sal_uInt8*    pBlop = writer.getBlop();
         sal_uInt32          aBlopSize = writer.getBlopSize();
 
-        sal_uInt8   type = (sal_uInt8)RG_VALUETYPE_BINARY;
+        sal_uInt8   type = (sal_uInt8)RegValueType::BINARY;
         sal_uInt8*  pBuffer = static_cast<sal_uInt8*>(rtl_allocateMemory(VALUE_HEADERSIZE + aBlopSize));
 
         memcpy(pBuffer, &type, 1);
@@ -1509,12 +1509,12 @@ RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_
     const sal_Char* indent = sIndent.getStr();
     switch (valueType)
     {
-        case 0:
+        case RegValueType::NOT_DEFINED:
             fprintf(stdout, "%sValue: Type = VALUETYPE_NOT_DEFINED\n", indent);
             break;
-        case 1:
+        case RegValueType::LONG:
             {
-                fprintf(stdout, "%sValue: Type = RG_VALUETYPE_LONG\n", indent);
+                fprintf(stdout, "%sValue: Type = RegValueType::LONG\n", indent);
                 fprintf(
                     stdout, "%s       Size = %lu\n", indent,
                     sal::static_int_cast< unsigned long >(valueSize));
@@ -1525,11 +1525,11 @@ RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_
                 fprintf(stdout, "%ld\n", sal::static_int_cast< long >(value));
             }
             break;
-        case 2:
+        case RegValueType::STRING:
             {
                 sal_Char* value = static_cast<sal_Char*>(rtl_allocateMemory(valueSize));
                 readUtf8(pBuffer, value, valueSize);
-                fprintf(stdout, "%sValue: Type = RG_VALUETYPE_STRING\n", indent);
+                fprintf(stdout, "%sValue: Type = RegValueType::STRING\n", indent);
                 fprintf(
                     stdout, "%s       Size = %lu\n", indent,
                     sal::static_int_cast< unsigned long >(valueSize));
@@ -1537,10 +1537,10 @@ RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_
                 rtl_freeMemory(value);
             }
             break;
-        case 3:
+        case RegValueType::UNICODE:
             {
                 sal_uInt32 size = (valueSize / 2) * sizeof(sal_Unicode);
-                fprintf(stdout, "%sValue: Type = RG_VALUETYPE_UNICODE\n", indent);
+                fprintf(stdout, "%sValue: Type = RegValueType::UNICODE\n", indent);
                 fprintf(
                     stdout, "%s       Size = %lu\n", indent,
                     sal::static_int_cast< unsigned long >(valueSize));
@@ -1554,9 +1554,9 @@ RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_
                 delete[] value;
             }
             break;
-        case 4:
+        case RegValueType::BINARY:
             {
-                fprintf(stdout, "%sValue: Type = RG_VALUETYPE_BINARY\n", indent);
+                fprintf(stdout, "%sValue: Type = RegValueType::BINARY\n", indent);
                 fprintf(
                     stdout, "%s       Size = %lu\n", indent,
                     sal::static_int_cast< unsigned long >(valueSize));
@@ -1567,14 +1567,14 @@ RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_
                     sIndent + "              ");
             }
             break;
-        case 5:
+        case RegValueType::LONGLIST:
             {
                 sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
                 sal_uInt32 len = 0;
 
                 readUINT32(pBuffer, len);
 
-                fprintf(stdout, "%sValue: Type = RG_VALUETYPE_LONGLIST\n", indent);
+                fprintf(stdout, "%sValue: Type = RegValueType::LONGLIST\n", indent);
                 fprintf(
                     stdout, "%s       Size = %lu\n", indent,
                     sal::static_int_cast< unsigned long >(valueSize));
@@ -1599,7 +1599,7 @@ RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_
                 }
             }
             break;
-        case 6:
+        case RegValueType::STRINGLIST:
             {
                 sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
                 sal_uInt32 sLen = 0;
@@ -1607,7 +1607,7 @@ RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_
 
                 readUINT32(pBuffer, len);
 
-                fprintf(stdout, "%sValue: Type = RG_VALUETYPE_STRINGLIST\n", indent);
+                fprintf(stdout, "%sValue: Type = RegValueType::STRINGLIST\n", indent);
                 fprintf(
                     stdout, "%s       Size = %lu\n", indent,
                     sal::static_int_cast< unsigned long >(valueSize));
@@ -1636,7 +1636,7 @@ RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_
                 }
             }
             break;
-        case 7:
+        case RegValueType::UNICODELIST:
             {
                 sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
                 sal_uInt32 sLen = 0;
@@ -1644,7 +1644,7 @@ RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_
 
                 readUINT32(pBuffer, len);
 
-                fprintf(stdout, "%sValue: Type = RG_VALUETYPE_UNICODELIST\n", indent);
+                fprintf(stdout, "%sValue: Type = RegValueType::UNICODELIST\n", indent);
                 fprintf(
                     stdout, "%s       Size = %lu\n", indent,
                     sal::static_int_cast< unsigned long >(valueSize));
diff --git a/registry/source/regkey.cxx b/registry/source/regkey.cxx
index 3170a0c5f9db..7c71336a4e4c 100644
--- a/registry/source/regkey.cxx
+++ b/registry/source/regkey.cxx
@@ -372,7 +372,7 @@ RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey,
                                         RegValueType* pValueType,
                                         sal_uInt32* pValueSize)
 {
-    *pValueType = RG_VALUETYPE_NOT_DEFINED;
+    *pValueType = RegValueType::NOT_DEFINED;
     *pValueSize = 0;
 
     ORegKey* pKey = static_cast< ORegKey* >(hKey);
@@ -576,12 +576,12 @@ RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType,
 {
     switch (valueType)
     {
-        case 5:
+        case RegValueType::LONGLIST:
             {
                 rtl_freeMemory(pValueList);
             }
             break;
-        case 6:
+        case RegValueType::STRINGLIST:
             {
                 sal_Char** pVList = static_cast<sal_Char**>(pValueList);
                 for (sal_uInt32 i=0; i < len; i++)
@@ -592,7 +592,7 @@ RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType,
                 rtl_freeMemory(pVList);
             }
             break;
-        case 7:
+        case RegValueType::UNICODELIST:
             {
                 sal_Unicode** pVList = static_cast<sal_Unicode**>(pValueList);
                 for (sal_uInt32 i=0; i < len; i++)
diff --git a/registry/test/testmerge.cxx b/registry/test/testmerge.cxx
index 44ae7944ccb7..48eb384473b6 100644
--- a/registry/test/testmerge.cxx
+++ b/registry/test/testmerge.cxx
@@ -53,16 +53,16 @@ void test_generateMerge1()
     REG_ENSURE(!rootKey.createKey(OUString("MergeKey1"), key1), "testGenerateMerge1 error 3");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey1"), key2), "testGenerateMerge1 error 4");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey1/KeyWithLongValue"), key3), "testGenerateMerge1 error 5");
-    REG_ENSURE(!key3.setValue(OUString(), RG_VALUETYPE_LONG, &lValue1, sizeof(sal_Int32)), "testGenerateMerge1 error 5a");
+    REG_ENSURE(!key3.setValue(OUString(), RegValueType::LONG, &lValue1, sizeof(sal_Int32)), "testGenerateMerge1 error 5a");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey2"), key4), "testGenerateMerge1 error 6");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey2/KeyWithStringValue"), key5), "testGenerateMerge1 error 7");
-    REG_ENSURE(!key5.setValue(OUString(), RG_VALUETYPE_STRING, sValue, strlen(sValue)+1), "testGenerateMerge1 error 7a");
+    REG_ENSURE(!key5.setValue(OUString(), RegValueType::STRING, sValue, strlen(sValue)+1), "testGenerateMerge1 error 7a");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey3"), key6), "testGenerateMerge1 error 8");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey3/KeyWithUnicodeValue"), key7), "testGenerateMerge1 error 9");
-    REG_ENSURE(!key7.setValue(OUString(), RG_VALUETYPE_UNICODE, (void*)wValue.getStr(), ((wValue.getLength()+1)*sizeof(sal_Unicode))), "testGenerateMerge1 error 9a");
+    REG_ENSURE(!key7.setValue(OUString(), RegValueType::UNICODE, (void*)wValue.getStr(), ((wValue.getLength()+1)*sizeof(sal_Unicode))), "testGenerateMerge1 error 9a");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey4"), key8), "testGenerateMerge1 error 10");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey4/KeyWithBinaryValue"), key9), "testGenerateMerge1 error 11");
-    REG_ENSURE(!key9.setValue(OUString(), RG_VALUETYPE_BINARY, (void*)"abcdefghijklmnopqrstuvwxyz", 27), "testGenerateMerge1 error 11a");
+    REG_ENSURE(!key9.setValue(OUString(), RegValueType::BINARY, (void*)"abcdefghijklmnopqrstuvwxyz", 27), "testGenerateMerge1 error 11a");
 
 
     REG_ENSURE(!key1.closeKey() &&
@@ -78,16 +78,16 @@ void test_generateMerge1()
     REG_ENSURE(!rootKey.createKey(OUString("MergeKey1u2"), key1), "testGenerateMerge1 error 13");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK1SubKey11"), key2), "testGenerateMerge1 error 14");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK1SubKey11/KeyWithLongValue"), key3), "testGenerateMerge1 error 15");
-    REG_ENSURE(!key3.setValue(OUString(), RG_VALUETYPE_LONG, &lValue2, sizeof(sal_Int32)), "testGenerateMerge1 error 15a");
+    REG_ENSURE(!key3.setValue(OUString(), RegValueType::LONG, &lValue2, sizeof(sal_Int32)), "testGenerateMerge1 error 15a");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK1SubKey12"), key4), "testGenerateMerge1 error 16");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK1SubKey12/KeyWithStringValue"), key5), "testGenerateMerge1 error 17");
-    REG_ENSURE(!key5.setValue(OUString(), RG_VALUETYPE_STRING, sValue, strlen(sValue)+1), "testGenerateMerge1 error 17a");
+    REG_ENSURE(!key5.setValue(OUString(), RegValueType::STRING, sValue, strlen(sValue)+1), "testGenerateMerge1 error 17a");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK1SubKey13"), key6), "testGenerateMerge1 error 18");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK1SubKey13/KeyWithUnicodeValue"), key7), "testGenerateMerge1 error 19");
-    REG_ENSURE(!key7.setValue(OUString(), RG_VALUETYPE_UNICODE, (void*)wValue.getStr(), ((wValue.getLength()+1)*sizeof(sal_Unicode))), "testGenerateMerge1 error 19a");
+    REG_ENSURE(!key7.setValue(OUString(), RegValueType::UNICODE, (void*)wValue.getStr(), ((wValue.getLength()+1)*sizeof(sal_Unicode))), "testGenerateMerge1 error 19a");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK12SubKey1u2"), key8), "testGenerateMerge1 error 20");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK12SubKey1u2/KeyWithLongValue"), key9), "testGenerateMerge1 error 21");
-    REG_ENSURE(!key9.setValue(OUString(), RG_VALUETYPE_LONG, &lValue3, sizeof(sal_Int32)), "testGenerateMerge1 error 21a");
+    REG_ENSURE(!key9.setValue(OUString(), RegValueType::LONG, &lValue3, sizeof(sal_Int32)), "testGenerateMerge1 error 21a");
 
     REG_ENSURE(!rootKey.closeKey() &&
                 !key1.closeKey() &&
@@ -119,16 +119,16 @@ void test_generateMerge2()
     REG_ENSURE(!rootKey.createKey(OUString("MergeKey2"), key1), "testGenerateMerge2 error 3");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey1"), key2), "testGenerateMerge2 error 4");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey1/KeyWithBinaryValue"), key3), "testGenerateMerge2 error 5");
-    REG_ENSURE(!key3.setValue(OUString(), RG_VALUETYPE_BINARY, (void*)"1234567890", 11), "testGenerateMerge1 error 5a");
+    REG_ENSURE(!key3.setValue(OUString(), RegValueType::BINARY, (void*)"1234567890", 11), "testGenerateMerge1 error 5a");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey2"), key4), "testGenerateMerge2 error 6");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey2/KeyWithUnicodeValue"), key5), "testGenerateMerge2 error 7");
-    REG_ENSURE(!key5.setValue(OUString(), RG_VALUETYPE_UNICODE, (void*)wValue.getStr(), ((wValue.getLength()+1)*sizeof(sal_Unicode))), "testGenerateMerge1 error 7a");
+    REG_ENSURE(!key5.setValue(OUString(), RegValueType::UNICODE, (void*)wValue.getStr(), ((wValue.getLength()+1)*sizeof(sal_Unicode))), "testGenerateMerge1 error 7a");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey3"), key6), "testGenerateMerge2 error 8");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey3/KeyWithStringValue"), key7), "testGenerateMerge2 error 9");
-    REG_ENSURE(!key7.setValue(OUString(), RG_VALUETYPE_STRING, sValue, strlen(sValue)+1), "testGenerateMerge1 error 9a");
+    REG_ENSURE(!key7.setValue(OUString(), RegValueType::STRING, sValue, strlen(sValue)+1), "testGenerateMerge1 error 9a");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey4"), key8), "testGenerateMerge2 error 10");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey4/KeyWithLongValue"), key9), "testGenerateMerge2 error 11");
-    REG_ENSURE(!key9.setValue(OUString(), RG_VALUETYPE_LONG, &lValue1, sizeof(sal_Int32)), "testGenerateMerge1 error 11a");
+    REG_ENSURE(!key9.setValue(OUString(), RegValueType::LONG, &lValue1, sizeof(sal_Int32)), "testGenerateMerge1 error 11a");
 
     REG_ENSURE(!key1.closeKey() &&
                 !key2.closeKey() &&
@@ -143,16 +143,16 @@ void test_generateMerge2()
     REG_ENSURE(!rootKey.createKey(OUString("MergeKey1u2"), key1), "testGenerateMerge2 error 13");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK2SubKey21"), key2), "testGenerateMerge2 error 14");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK2SubKey21/KeyWithBinaryValue"), key3), "testGenerateMerge2 error 15");
-    REG_ENSURE(!key3.setValue(OUString(), RG_VALUETYPE_BINARY, (void*)"a1b2c3d4e5f6g7h8i9", 19), "testGenerateMerge1 error 15a");
+    REG_ENSURE(!key3.setValue(OUString(), RegValueType::BINARY, (void*)"a1b2c3d4e5f6g7h8i9", 19), "testGenerateMerge1 error 15a");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK2SubKey22"), key4), "testGenerateMerge2 error 16");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK2SubKey22/KeyWithLongValue"), key5), "testGenerateMerge2 error 17");
-    REG_ENSURE(!key5.setValue(OUString(), RG_VALUETYPE_LONG, &lValue2, sizeof(sal_Int32)), "testGenerateMerge1 error 17a");
+    REG_ENSURE(!key5.setValue(OUString(), RegValueType::LONG, &lValue2, sizeof(sal_Int32)), "testGenerateMerge1 error 17a");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK2SubKey23"), key6), "testGenerateMerge2 error 18");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK2SubKey23/KeyWithStringValue"), key7), "testGenerateMerge2 error 19");
-    REG_ENSURE(!key7.setValue(OUString(), RG_VALUETYPE_STRING, sValue, strlen(sValue)+1), "testGenerateMerge1 error 19a");
+    REG_ENSURE(!key7.setValue(OUString(), RegValueType::STRING, sValue, strlen(sValue)+1), "testGenerateMerge1 error 19a");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK12SubKey1u2"), key8), "testGenerateMerge2 error 20");
     REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK12SubKey1u2/KeyWithLongValue"), key9), "testGenerateMerge2 error 21");
-    REG_ENSURE(!key9.setValue(OUString(), RG_VALUETYPE_LONG, &lValue4, sizeof(sal_Int32)), "testGenerateMerge1 error 21a");
+    REG_ENSURE(!key9.setValue(OUString(), RegValueType::LONG, &lValue4, sizeof(sal_Int32)), "testGenerateMerge1 error 21a");
 
     REG_ENSURE(!rootKey.closeKey() &&
                 !key1.closeKey() &&
@@ -298,97 +298,97 @@ void test_merge()
     REG_ENSURE(!rootKey.openKey("/stardiv/IchbineinMergeKey", key1), "testMerge error 72");
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1/MK1SubKey1/KeyWithLongValue"), &valueType, &valueSize), "testMerge error 73");
-    REG_ENSURE(valueType == RG_VALUETYPE_LONG && valueSize == sizeof(sal_Int32), "testMerge error 74");
+    REG_ENSURE(valueType == RegValueType::LONG && valueSize == sizeof(sal_Int32), "testMerge error 74");
     REG_ENSURE(!key1.getValue(OUString("/MergeKey1/MK1SubKey1/KeyWithLongValue"), (RegValue)&int32Value), "testMerge error 74.a)");
     REG_ENSURE(int32Value == lValue1, "testMerge error 74.b)");
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1/MK1SubKey2/KeyWithStringValue"), &valueType, &valueSize), "testMerge error 75");
-    REG_ENSURE(valueType == RG_VALUETYPE_STRING && valueSize == strlen(sValue)+1, "testMerge error 76");
+    REG_ENSURE(valueType == RegValueType::STRING && valueSize == strlen(sValue)+1, "testMerge error 76");
     Value = new sal_uInt8[valueSize];
     REG_ENSURE(!key1.getValue(OUString("/MergeKey1/MK1SubKey2/KeyWithStringValue"), (RegValue)Value), "testMerge error 76.a)");
     REG_ENSURE(strcmp((const sal_Char*)Value, sValue) == 0, "testMerge error 76.b)");
     delete [] Value;
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1/MK1SubKey3/KeyWithUnicodeValue"), &valueType, &valueSize), "testMerge error 77");
-    REG_ENSURE(valueType == RG_VALUETYPE_UNICODE && valueSize == (wValue.getLength()+1)*sizeof(sal_Unicode), "testMerge error 78");
+    REG_ENSURE(valueType == RegValueType::UNICODE && valueSize == (wValue.getLength()+1)*sizeof(sal_Unicode), "testMerge error 78");
     Value = new sal_uInt8[valueSize];
     REG_ENSURE(!key1.getValue(OUString("/MergeKey1/MK1SubKey3/KeyWithUnicodeValue"), (RegValue)Value), "testMerge error 78.a)");
     REG_ENSURE(wValue.equals( (const sal_Unicode*)Value ), "testMerge error 78.b)");
     delete [] Value;
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1/MK1SubKey4/KeyWithBinaryValue"), &valueType, &valueSize), "testMerge error 79");
-    REG_ENSURE(valueType == RG_VALUETYPE_BINARY && valueSize == 27, "testMerge error 80");
+    REG_ENSURE(valueType == RegValueType::BINARY && valueSize == 27, "testMerge error 80");
     Value = new sal_uInt8[valueSize];
     REG_ENSURE(!key1.getValue(OUString("/MergeKey1/MK1SubKey4/KeyWithBinaryValue"), (RegValue)Value), "testMerge error 80.a)");
     REG_ENSURE(strcmp((const sal_Char*)Value, "abcdefghijklmnopqrstuvwxyz") == 0, "testMerge error 80.b)");
     delete [] Value;
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey2/MK2SubKey1/KeyWithBinaryValue"), &valueType, &valueSize), "testMerge error 81");
-    REG_ENSURE(valueType == RG_VALUETYPE_BINARY && valueSize == 11, "testMerge error 82");
+    REG_ENSURE(valueType == RegValueType::BINARY && valueSize == 11, "testMerge error 82");
     Value = new sal_uInt8[valueSize];
     REG_ENSURE(!key1.getValue(OUString("/MergeKey2/MK2SubKey1/KeyWithBinaryValue"), (RegValue)Value), "testMerge error 82.a)");
     REG_ENSURE(strcmp((const sal_Char*)Value, "1234567890") == 0, "testMerge error 82.b)");
     delete [] Value;
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey2/MK2SubKey2/KeyWithUnicodeValue"), &valueType, &valueSize), "testMerge error 83");
-    REG_ENSURE(valueType == RG_VALUETYPE_UNICODE&& valueSize == (wValue.getLength()+1)*sizeof(sal_Unicode), "testMerge error 84");
+    REG_ENSURE(valueType == RegValueType::UNICODE&& valueSize == (wValue.getLength()+1)*sizeof(sal_Unicode), "testMerge error 84");
     Value = new sal_uInt8[valueSize];
     REG_ENSURE(!key1.getValue(OUString("/MergeKey2/MK2SubKey2/KeyWithUnicodeValue"), (RegValue)Value), "testMerge error 84.a)");
     REG_ENSURE(wValue.equals( (const sal_Unicode*)Value ), "testMerge error 84.b)");
     delete [] Value;
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey2/MK2SubKey3/KeyWithStringValue"), &valueType, &valueSize), "testMerge error 85");
-    REG_ENSURE(valueType == RG_VALUETYPE_STRING && valueSize == strlen(sValue)+1, "testMerge error 86");
+    REG_ENSURE(valueType == RegValueType::STRING && valueSize == strlen(sValue)+1, "testMerge error 86");
     Value = new sal_uInt8[valueSize];
     REG_ENSURE(!key1.getValue(OUString("/MergeKey2/MK2SubKey3/KeyWithStringValue"), (RegValue)Value), "testMerge error 86.a)");
     REG_ENSURE(strcmp((const sal_Char*)Value, sValue) == 0, "testMerge error 86.b)");
     delete [] Value;
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey2/MK2SubKey4/KeyWithLongValue"), &valueType, &valueSize), "testMerge error 87");
-    REG_ENSURE(valueType == RG_VALUETYPE_LONG && valueSize == sizeof(sal_Int32), "testMerge error 88");
+    REG_ENSURE(valueType == RegValueType::LONG && valueSize == sizeof(sal_Int32), "testMerge error 88");
     REG_ENSURE(!key1.getValue(OUString("/MergeKey2/MK2SubKey4/KeyWithLongValue"), (RegValue)&int32Value), "testMerge error 88.a)");
     REG_ENSURE(int32Value == lValue1, "testMerge error 88.b)");
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1u2/MK1SubKey11/KeyWithLongValue"), &valueType, &valueSize), "testMerge error 89");
-    REG_ENSURE(valueType == RG_VALUETYPE_LONG && valueSize == sizeof(sal_Int32), "testMerge error 90");
+    REG_ENSURE(valueType == RegValueType::LONG && valueSize == sizeof(sal_Int32), "testMerge error 90");
     REG_ENSURE(!key1.getValue(OUString("/MergeKey1u2/MK1SubKey11/KeyWithLongValue"), (RegValue)&int32Value), "testMerge error 90.a)");
     REG_ENSURE(int32Value == lValue2, "testMerge error 90.b)");
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1u2/MK1SubKey12/KeyWithStringValue"), &valueType, &valueSize), "testMerge error 91");
-    REG_ENSURE(valueType == RG_VALUETYPE_STRING && valueSize == strlen(sValue)+1, "testMerge error 92");
+    REG_ENSURE(valueType == RegValueType::STRING && valueSize == strlen(sValue)+1, "testMerge error 92");
     Value = new sal_uInt8[valueSize];
     REG_ENSURE(!key1.getValue(OUString("/MergeKey1u2/MK1SubKey12/KeyWithStringValue"), (RegValue)Value), "testMerge error 92.a)");
     REG_ENSURE(strcmp((const sal_Char*)Value, sValue) == 0, "testMerge error 92.b)");
     delete [] Value;
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1u2/MK1SubKey13/KeyWithUnicodeValue"), &valueType, &valueSize), "testMerge error 93");
-    REG_ENSURE(valueType == RG_VALUETYPE_UNICODE && valueSize == (wValue.getLength()+1)*sizeof(sal_Unicode), "testMerge error 94");
+    REG_ENSURE(valueType == RegValueType::UNICODE && valueSize == (wValue.getLength()+1)*sizeof(sal_Unicode), "testMerge error 94");
     Value = new sal_uInt8[valueSize];
     REG_ENSURE(!key1.getValue(OUString("/MergeKey1u2/MK1SubKey13/KeyWithUnicodeValue"), (RegValue)Value), "testMerge error 94.a)");
     REG_ENSURE(wValue.equals( (const sal_Unicode*)Value ), "testMerge error 94.b)");
     delete [] Value;
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1u2/MK2SubKey21/KeyWithBinaryValue"), &valueType, &valueSize), "testMerge error 95");
-    REG_ENSURE(valueType == RG_VALUETYPE_BINARY && valueSize == 19, "testMerge error 96");
+    REG_ENSURE(valueType == RegValueType::BINARY && valueSize == 19, "testMerge error 96");
     Value = new sal_uInt8[valueSize];
     REG_ENSURE(!key1.getValue(OUString("/MergeKey1u2/MK2SubKey21/KeyWithBinaryValue"), (RegValue)Value), "testMerge error 96.a)");
     REG_ENSURE(strcmp((const sal_Char*)Value, "a1b2c3d4e5f6g7h8i9") == 0, "testMerge error 96.b)");
     delete [] Value;
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1u2/MK2SubKey22/KeyWithLongValue"), &valueType, &valueSize), "testMerge error 97");
-    REG_ENSURE(valueType == RG_VALUETYPE_LONG && valueSize == sizeof(sal_Int32), "testMerge error 98");
+    REG_ENSURE(valueType == RegValueType::LONG && valueSize == sizeof(sal_Int32), "testMerge error 98");
     REG_ENSURE(!key1.getValue(OUString("/MergeKey1u2/MK2SubKey22/KeyWithLongValue"), (RegValue)&int32Value), "testMerge error 98.a)");
     REG_ENSURE(int32Value == lValue2, "testMerge error 98.b)");
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1u2/MK2SubKey23/KeyWithStringValue"), &valueType, &valueSize), "testMerge error 99");
-    REG_ENSURE(valueType == RG_VALUETYPE_STRING && valueSize == strlen(sValue)+1, "testMerge error 100");
+    REG_ENSURE(valueType == RegValueType::STRING && valueSize == strlen(sValue)+1, "testMerge error 100");
     Value = new sal_uInt8[valueSize];
     REG_ENSURE(!key1.getValue(OUString("/MergeKey1u2/MK2SubKey23/KeyWithStringValue"), (RegValue)Value), "testMerge error 100.a)");
     REG_ENSURE(strcmp((const sal_Char*)Value, sValue) == 0, "testMerge error 100.b)");
     delete [] Value;
 
     REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1u2/MK12SubKey1u2/KeyWithLongValue"), &valueType, &valueSize), "testMerge error 101");
-    REG_ENSURE(valueType == RG_VALUETYPE_LONG && valueSize == sizeof(sal_Int32), "testMerge error 102");
+    REG_ENSURE(valueType == RegValueType::LONG && valueSize == sizeof(sal_Int32), "testMerge error 102");
     REG_ENSURE(!key1.getValue(OUString("/MergeKey1u2/MK12SubKey1u2/KeyWithLongValue"), (RegValue)&int32Value), "testMerge error 102.a)");
     REG_ENSURE(int32Value == lValue4, "testMerge error 102.b)");
 
diff --git a/registry/test/testregcpp.cxx b/registry/test/testregcpp.cxx
index 1eb16831d31f..514accf99822 100644
--- a/registry/test/testregcpp.cxx
+++ b/registry/test/testregcpp.cxx
@@ -131,7 +131,7 @@ void test_coreReflection()
         const sal_uInt8* pBlop = writer.getBlop();
         sal_uInt32      aBlopSize = writer.getBlopSize();
 
-        REG_ENSURE(!key2.setValue(OUString(), RG_VALUETYPE_BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9");
+        REG_ENSURE(!key2.setValue(OUString(), RegValueType::BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9");
 
         sal_uInt8* readBlop = (sal_uInt8*)rtl_allocateMemory(aBlopSize);
         REG_ENSURE(!key2.getValue(OUString(), (void*)readBlop) , "testCoreReflection error 9a");
@@ -178,7 +178,7 @@ void test_coreReflection()
         const sal_uInt8* pBlop = writer.getBlop();
         sal_uInt32      aBlopSize = writer.getBlopSize();
 
-        REG_ENSURE(!key3.setValue(OUString(), RG_VALUETYPE_BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9a");
+        REG_ENSURE(!key3.setValue(OUString(), RegValueType::BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9a");
     }
 
     {
@@ -205,7 +205,7 @@ void test_coreReflection()
         const sal_uInt8* pBlop = writer.getBlop();
         sal_uInt32      aBlopSize = writer.getBlopSize();
 
-        REG_ENSURE(!key4.setValue(OUString(), RG_VALUETYPE_BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9b");
+        REG_ENSURE(!key4.setValue(OUString(), RegValueType::BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9b");
     }
 
     {
@@ -246,7 +246,7 @@ void test_coreReflection()
         const sal_uInt8* pBlop = writer.getBlop();
         sal_uInt32      aBlopSize = writer.getBlopSize();
 
-        REG_ENSURE(!key5.setValue(OUString(), RG_VALUETYPE_BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9c");
+        REG_ENSURE(!key5.setValue(OUString(), RegValueType::BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9c");
 
         sal_uInt8* readBlop = (sal_uInt8*)rtl_allocateMemory(aBlopSize);
         REG_ENSURE(!key5.getValue(OUString(), (void*)readBlop) , "testCoreReflection error 9c1");
@@ -283,7 +283,7 @@ void test_coreReflection()
         const sal_uInt8* pBlop = writer.getBlop();
         sal_uInt32      aBlopSize = writer.getBlopSize();
 
-        REG_ENSURE(!key6.setValue(OUString(), RG_VALUETYPE_BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9d");
+        REG_ENSURE(!key6.setValue(OUString(), RegValueType::BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9d");
     }
 
     {
@@ -312,7 +312,7 @@ void test_coreReflection()
         const sal_uInt8* pBlop = writer.getBlop();
         sal_uInt32      aBlopSize = writer.getBlopSize();
 
-        REG_ENSURE(!key7.setValue(OUString(), RG_VALUETYPE_BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9e");
+        REG_ENSURE(!key7.setValue(OUString(), RegValueType::BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9e");
         sal_uInt8* readBlop = (sal_uInt8*)rtl_allocateMemory(aBlopSize);
         REG_ENSURE(!key7.getValue(OUString(), (void*)readBlop) , "testCoreReflection error 9e2");
 
@@ -362,7 +362,7 @@ void test_coreReflection()
         const sal_uInt8* pBlop = writer.getBlop();
         sal_uInt32      aBlopSize = writer.getBlopSize();
 
-        REG_ENSURE(!key8.setValue(OUString(), RG_VALUETYPE_BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9f");
+        REG_ENSURE(!key8.setValue(OUString(), RegValueType::BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9f");
     }
 
 //  REG_ENSURE(!myRegistry->destroy(NULL), "testCoreReflection error 10");
@@ -492,7 +492,7 @@ void test_registry_CppApi()
 
 
     sal_Char* Value=(sal_Char*)"Mein erster Value";
-    REG_ENSURE(!rootKey.setValue(OUString("mySecondKey"), RG_VALUETYPE_STRING, Value, 18), "test_registry_CppApi error 9");
+    REG_ENSURE(!rootKey.setValue(OUString("mySecondKey"), RegValueType::STRING, Value, 18), "test_registry_CppApi error 9");
 
     RegValueType    valueType;
     sal_uInt32          valueSize;
@@ -502,7 +502,7 @@ void test_registry_CppApi()
     readValue = (sal_Char*)rtl_allocateMemory(valueSize);
     REG_ENSURE(!key2.getValue(OUString(), readValue), "test_registry_CppApi error 10");
 
-    REG_ENSURE(valueType == RG_VALUETYPE_STRING, "test_registry_CppApi error 11");
+    REG_ENSURE(valueType == RegValueType::STRING, "test_registry_CppApi error 11");
     REG_ENSURE(valueSize == 18, "test_registry_CppApi error 12");
     REG_ENSURE(strcmp(readValue, Value) == 0, "test_registry_CppApi error 13");
     rtl_freeMemory(readValue);
@@ -526,7 +526,7 @@ void test_registry_CppApi()
     REG_ENSURE(strcmp(n3, valueList.getElement(2)) == 0, "test_registry_CppApi error 13e");
 
     REG_ENSURE(!rootKey.getValueInfo(OUString("myFourthKey"), &valueType, &valueSize), "test_registry_CppApi error 13e1");
-    REG_ENSURE(valueType == RG_VALUETYPE_STRINGLIST, "test_registry_CppApi error 13e2");
+    REG_ENSURE(valueType == RegValueType::STRINGLIST, "test_registry_CppApi error 13e2");
     REG_ENSURE(valueSize == 3, "test_registry_CppApi error 13e3");
 
     sal_Int32 pLong[3];
@@ -546,7 +546,7 @@ void test_registry_CppApi()
 
     OUString sWTestValue("Mein erster Unicode Value");
     const sal_Unicode* wTestValue= sWTestValue.getStr();
-    REG_ENSURE(!rootKey.setValue(OUString("mySixthKey"), RG_VALUETYPE_UNICODE, (void*)wTestValue,
+    REG_ENSURE(!rootKey.setValue(OUString("mySixthKey"), RegValueType::UNICODE, (void*)wTestValue,
                 (rtl_ustr_getLength(wTestValue)+1)*sizeof(sal_Unicode)), "test_registry_CppApi error 13j1");
 
     REG_ENSURE(!rootKey.getValueInfo(OUString("mySixthKey"), &valueType, &valueSize), "test_registry_CppApi error 13j2");
@@ -608,7 +608,7 @@ void test_registry_CppApi()
     REG_ENSURE(!rootKey2.createKey(OUString("reg2ThirdKey"), key25), "test_registry_CppApi error 29");
 
     sal_uInt32 nValue= 123456789;
-    REG_ENSURE(!key23.setValue(OUString(), RG_VALUETYPE_LONG, &nValue, sizeof(sal_uInt32)), "test_registry_CppApi error 30");
+    REG_ENSURE(!key23.setValue(OUString(), RegValueType::LONG, &nValue, sizeof(sal_uInt32)), "test_registry_CppApi error 30");
 
     REG_ENSURE(!key21.closeKey() &&
                !key22.closeKey() &&
@@ -643,7 +643,7 @@ void test_registry_CppApi()
                 !key2.closeKey(), "test_registry_CppApi error 41");
 
     const sal_Unicode* wValue= OUString("Mein erster Unicode Value").getStr();
-    REG_ENSURE(!key3.setValue(OUString(), RG_VALUETYPE_UNICODE, (void*)wValue,
+    REG_ENSURE(!key3.setValue(OUString(), RegValueType::UNICODE, (void*)wValue,
                 (rtl_ustr_getLength(wValue)+1)*sizeof(sal_Unicode)), "test_registry_CppApi error 42");
 
     REG_ENSURE(!key3.closeKey(), "test_registry_CppApi error 43");
diff --git a/registry/tools/regcompare.cxx b/registry/tools/regcompare.cxx
index 583b3f736c92..771a2bbba0b1 100644
--- a/registry/tools/regcompare.cxx
+++ b/registry/tools/regcompare.cxx
@@ -1321,7 +1321,7 @@ static sal_uInt32 checkValueDifference(
         bool bEqual = true;
         switch (valueType1)
         {
-        case RG_VALUETYPE_LONGLIST:
+        case RegValueType::LONGLIST:
             {
                 RegistryValueList<sal_Int32> valueList1;
                 RegistryValueList<sal_Int32> valueList2;
@@ -1344,7 +1344,7 @@ static sal_uInt32 checkValueDifference(
                 }
             }
             break;
-        case RG_VALUETYPE_STRINGLIST:
+        case RegValueType::STRINGLIST:
             {
                 RegistryValueList<sal_Char*> valueList1;
                 RegistryValueList<sal_Char*> valueList2;
@@ -1367,7 +1367,7 @@ static sal_uInt32 checkValueDifference(
                 }
             }
             break;
-        case RG_VALUETYPE_UNICODELIST:
+        case RegValueType::UNICODELIST:
             {
                 RegistryValueList<sal_Unicode*> valueList1;
                 RegistryValueList<sal_Unicode*> valueList2;
@@ -1403,7 +1403,7 @@ static sal_uInt32 checkValueDifference(
             key2.getValue(tmpName, &value2[0]);
 
             bEqual = (memcmp(&value1[0], &value2[0], value1.size()) == 0 );
-            if ( !bEqual && valueType1 == RG_VALUETYPE_BINARY && valueType2 == RG_VALUETYPE_BINARY )
+            if ( !bEqual && valueType1 == RegValueType::BINARY && valueType2 == RegValueType::BINARY )
             {
                 typereg::Reader reader1(&value1[0], value1.size(), false, TYPEREG_VERSION_1);
                 typereg::Reader reader2(&value2[0], value2.size(), false, TYPEREG_VERSION_1);
@@ -1431,54 +1431,54 @@ static sal_uInt32 checkValueDifference(
     {
         switch (valueType1)
         {
-        case RG_VALUETYPE_NOT_DEFINED:
+        case RegValueType::NOT_DEFINED:
             fprintf(stdout, "    Registry 1: key has no value\n");
             break;
-        case RG_VALUETYPE_LONG:
+        case RegValueType::LONG:
             {
                 std::vector< sal_uInt8 > value1(size1);
                 key1.getValue(tmpName, &value1[0]);
 
-                fprintf(stdout, "    Registry 1: Value: Type = RG_VALUETYPE_LONG\n");
+                fprintf(stdout, "    Registry 1: Value: Type = RegValueType::LONG\n");
                 fprintf(
                     stdout, "                       Size = %lu\n",
                     sal::static_int_cast< unsigned long >(size1));
                 fprintf(stdout, "                       Data = %p\n", &value1[0]);
             }
             break;
-        case RG_VALUETYPE_STRING:
+        case RegValueType::STRING:
             {
                 std::vector< sal_uInt8 > value1(size1);
                 key1.getValue(tmpName, &value1[0]);
 
-                fprintf(stdout, "    Registry 1: Value: Type = RG_VALUETYPE_STRING\n");
+                fprintf(stdout, "    Registry 1: Value: Type = RegValueType::STRING\n");
                 fprintf(
                     stdout, "                       Size = %lu\n",
                     sal::static_int_cast< unsigned long >(size1));
                 fprintf(stdout, "                       Data = \"%s\"\n", reinterpret_cast<char const*>(&value1[0]));
             }
             break;
-        case RG_VALUETYPE_UNICODE:
+        case RegValueType::UNICODE:
             {
                 std::vector< sal_uInt8 > value1(size1);
                 key1.getValue(tmpName, &value1[0]);
 
                 OUString uStrValue(reinterpret_cast<sal_Unicode const*>(&value1[0]));
-                fprintf(stdout, "    Registry 1: Value: Type = RG_VALUETYPE_UNICODE\n");
+                fprintf(stdout, "    Registry 1: Value: Type = RegValueType::UNICODE\n");
                 fprintf(
                     stdout, "                       Size = %lu\n",
                     sal::static_int_cast< unsigned long >(size1));
                 fprintf(stdout, "                       Data = \"%s\"\n", U2S(uStrValue));
             }
             break;
-        case RG_VALUETYPE_BINARY:
-            fprintf(stdout, "    Registry 1: Value: Type = RG_VALUETYPE_BINARY\n");
+        case RegValueType::BINARY:
+            fprintf(stdout, "    Registry 1: Value: Type = RegValueType::BINARY\n");
             break;
-        case RG_VALUETYPE_LONGLIST:
+        case RegValueType::LONGLIST:
             {
                 RegistryValueList<sal_Int32> valueList;
                 key1.getLongListValue(tmpName, valueList);
-                fprintf(stdout, "    Registry 1: Value: Type = RG_VALUETYPE_LONGLIST\n");
+                fprintf(stdout, "    Registry 1: Value: Type = RegValueType::LONGLIST\n");
                 fprintf(
                     stdout, "                       Size = %lu\n",
                     sal::static_int_cast< unsigned long >(size1));
@@ -1492,11 +1492,11 @@ static sal_uInt32 checkValueDifference(
                 }
             }
             break;
-        case RG_VALUETYPE_STRINGLIST:
+        case RegValueType::STRINGLIST:
             {
                 RegistryValueList<sal_Char*> valueList;
                 key1.getStringListValue(tmpName, valueList);
-                fprintf(stdout, "    Registry 1: Value: Type = RG_VALUETYPE_STRINGLIST\n");
+                fprintf(stdout, "    Registry 1: Value: Type = RegValueType::STRINGLIST\n");
                 fprintf(
                     stdout, "                       Size = %lu\n",
                     sal::static_int_cast< unsigned long >(size1));
@@ -1510,11 +1510,11 @@ static sal_uInt32 checkValueDifference(
                 }
             }
             break;
-        case RG_VALUETYPE_UNICODELIST:
+        case RegValueType::UNICODELIST:
             {
                 RegistryValueList<sal_Unicode*> valueList;
                 key1.getUnicodeListValue(tmpName, valueList);
-                fprintf(stdout, "    Registry 1: Value: Type = RG_VALUETYPE_UNICODELIST\n");
+                fprintf(stdout, "    Registry 1: Value: Type = RegValueType::UNICODELIST\n");
                 fprintf(
                     stdout, "                       Size = %lu\n",
                     sal::static_int_cast< unsigned long >(size1));
@@ -1533,54 +1533,54 @@ static sal_uInt32 checkValueDifference(
 
         switch (valueType2)
         {
-        case RG_VALUETYPE_NOT_DEFINED:
+        case RegValueType::NOT_DEFINED:
             fprintf(stdout, "    Registry 2: key has no value\n");
             break;
-        case RG_VALUETYPE_LONG:
+        case RegValueType::LONG:
             {
                 std::vector< sal_uInt8 > value2(size2);
                 key2.getValue(tmpName, &value2[0]);
 
-                fprintf(stdout, "    Registry 2: Value: Type = RG_VALUETYPE_LONG\n");
+                fprintf(stdout, "    Registry 2: Value: Type = RegValueType::LONG\n");
                 fprintf(
                     stdout, "                       Size = %lu\n",
                     sal::static_int_cast< unsigned long >(size2));
                 fprintf(stdout, "                       Data = %p\n", &value2[0]);
             }
             break;
-        case RG_VALUETYPE_STRING:
+        case RegValueType::STRING:
             {
                 std::vector< sal_uInt8 > value2(size2);
                 key2.getValue(tmpName, &value2[0]);
 
-                fprintf(stdout, "    Registry 2: Value: Type = RG_VALUETYPE_STRING\n");
+                fprintf(stdout, "    Registry 2: Value: Type = RegValueType::STRING\n");
                 fprintf(
                     stdout, "                       Size = %lu\n",
                     sal::static_int_cast< unsigned long >(size2));
                 fprintf(stdout, "                       Data = \"%s\"\n", reinterpret_cast<char const*>(&value2[0]));
             }
             break;
-        case RG_VALUETYPE_UNICODE:
+        case RegValueType::UNICODE:
             {
                 std::vector< sal_uInt8 > value2(size2);
                 key2.getValue(tmpName, &value2[0]);
 
                 OUString uStrValue(reinterpret_cast<sal_Unicode const*>(&value2[0]));
-                fprintf(stdout, "    Registry 2: Value: Type = RG_VALUETYPE_UNICODE\n");
+                fprintf(stdout, "    Registry 2: Value: Type = RegValueType::UNICODE\n");
                 fprintf(
                     stdout, "                       Size = %lu\n",
                     sal::static_int_cast< unsigned long >(size2));
                 fprintf(stdout, "                       Data = \"%s\"\n", U2S(uStrValue));
             }
             break;
-        case RG_VALUETYPE_BINARY:
-            fprintf(stdout, "    Registry 2: Value: Type = RG_VALUETYPE_BINARY\n");
+        case RegValueType::BINARY:
+            fprintf(stdout, "    Registry 2: Value: Type = RegValueType::BINARY\n");
             break;
-        case RG_VALUETYPE_LONGLIST:
+        case RegValueType::LONGLIST:
             {
                 RegistryValueList<sal_Int32> valueList;
                 key2.getLongListValue(tmpName, valueList);
-                fprintf(stdout, "    Registry 2: Value: Type = RG_VALUETYPE_LONGLIST\n");
+                fprintf(stdout, "    Registry 2: Value: Type = RegValueType::LONGLIST\n");
                 fprintf(
                     stdout, "                       Size = %lu\n",
                     sal::static_int_cast< unsigned long >(size2));
@@ -1594,11 +1594,11 @@ static sal_uInt32 checkValueDifference(
                 }
             }
             break;
-        case RG_VALUETYPE_STRINGLIST:
+        case RegValueType::STRINGLIST:
             {
                 RegistryValueList<sal_Char*> valueList;
                 key2.getStringListValue(tmpName, valueList);
-                fprintf(stdout, "    Registry 2: Value: Type = RG_VALUETYPE_STRINGLIST\n");
+                fprintf(stdout, "    Registry 2: Value: Type = RegValueType::STRINGLIST\n");
                 fprintf(
                     stdout, "                       Size = %lu\n",
                     sal::static_int_cast< unsigned long >(size2));
@@ -1612,11 +1612,11 @@ static sal_uInt32 checkValueDifference(
                 }
             }
             break;
-        case RG_VALUETYPE_UNICODELIST:
+        case RegValueType::UNICODELIST:
             {
                 RegistryValueList<sal_Unicode*> valueList;
                 key2.getUnicodeListValue(tmpName, valueList);
-                fprintf(stdout, "    Registry 2: Value: Type = RG_VALUETYPE_UNICODELIST\n");
+                fprintf(stdout, "    Registry 2: Value: Type = RegValueType::UNICODELIST\n");
                 fprintf(
                     stdout, "                       Size = %lu\n",
                     sal::static_int_cast< unsigned long >(size2));
@@ -1675,7 +1675,7 @@ static bool hasPublishedChildren(Options_Impl const & options, RegistryKey & key
                             options.getRegName1().c_str());
                     }
                 }
-                else if (type == RG_VALUETYPE_BINARY)
+                else if (type == RegValueType::BINARY)
                 {
                     bool published = false;
                     std::vector< sal_uInt8 > value(size);
@@ -1777,7 +1777,7 @@ static sal_uInt32 checkDifferences(
                             }
                             ++nError;
                         }
-                        else if (type == RG_VALUETYPE_BINARY)
+                        else if (type == RegValueType::BINARY)
                         {
                             std::vector< sal_uInt8 > value(size);
                             if (subKey.getValue(OUString(), &value[0]) != REG_NO_ERROR)
@@ -1868,8 +1868,8 @@ static sal_uInt32 compareKeys(
 {
     sal_uInt32 nError = 0;
 
-    RegValueType valueType1 = RG_VALUETYPE_NOT_DEFINED;
-    RegValueType valueType2 = RG_VALUETYPE_NOT_DEFINED;
+    RegValueType valueType1 = RegValueType::NOT_DEFINED;
+    RegValueType valueType2 = RegValueType::NOT_DEFINED;
     sal_uInt32 size1 = 0;
     sal_uInt32 size2 = 0;
 
diff --git a/registry/workben/regtest.cxx b/registry/workben/regtest.cxx
index 2a891f7a0b6a..cf6b06dfd03e 100644
--- a/registry/workben/regtest.cxx
+++ b/registry/workben/regtest.cxx
@@ -91,7 +91,7 @@ int _cdecl main()
 
 
     char* Value=(char*)"Mein erster Value";
-    if (reg_setValue(hRootKey, OUString("mySecondKey").pData, RG_VALUETYPE_STRING, Value, 18))
+    if (reg_setValue(hRootKey, OUString("mySecondKey").pData, RegValueType::STRING, Value, 18))
         cout << "\t9. setValue of key \"mySecondKey\" failed\n";
     else
         cout << "9. setValue (string Value)  of key \"mySecondKey\"\n";
@@ -208,7 +208,7 @@ int _cdecl main()
         cout << "27. key \"reg2ThirdKey\" is created\n";
 
     sal_uInt32 nValue= 123456789;
-    if (reg_setValue(h2Key3, OUString().pData, RG_VALUETYPE_LONG, &nValue, sizeof(sal_uInt32)))
+    if (reg_setValue(h2Key3, OUString().pData, RegValueType::LONG, &nValue, sizeof(sal_uInt32)))
         cout << "\t27.b) setValue of key \"reg2FirstSubKey\" failed\n";
     else
         cout << "27.b). setValue (long Value)  of key \"reg2FirstSubKey\"\n";