convert RT_ACCESS fields to scoped enum

Change-Id: Ifef0aaae6208f18c1352fef7c471deb60a97820d

13 files changed, 178 insertions, 175 deletions

diff --git a/idlc/source/astconstant.cxx b/idlc/source/astconstant.cxx
index b37ff90e6b73..ce38dcbfa461 100644
--- a/idlc/source/astconstant.cxx
+++ b/idlc/source/astconstant.cxx
@@ -114,7 +114,7 @@ bool AstConstant::dumpBlob(
 
     rBlob.setFieldData(
         index, getDocumentation(), OUString(),
-        RT_ACCESS_CONST | (published ? RT_ACCESS_PUBLISHED : 0),
+        RTFieldAccess::CONST | (published ? RTFieldAccess::PUBLISHED : RTFieldAccess::NONE),
         OStringToOUString(name, RTL_TEXTENCODING_UTF8), type, aConst);
 
     return true;
diff --git a/idlc/source/astdump.cxx b/idlc/source/astdump.cxx
index d7adc08c90c1..c8691972b486 100644
--- a/idlc/source/astdump.cxx
+++ b/idlc/source/astdump.cxx
@@ -258,7 +258,7 @@ bool AstService::dump(RegistryKey& rKey)
             AstInterfaceMember * decl = static_cast<AstInterfaceMember *>(*i);
             writer.setReferenceData(
                 referenceIndex++, decl->getDocumentation(), RT_REF_SUPPORTS,
-                (decl->isOptional() ? RT_ACCESS_OPTIONAL : RT_ACCESS_INVALID),
+                (decl->isOptional() ? RTFieldAccess::OPTIONAL : RTFieldAccess::INVALID),
                 OStringToOUString( decl->getRealInterface()->getRelativName(),
                                         RTL_TEXTENCODING_UTF8));
             break;
@@ -269,7 +269,7 @@ bool AstService::dump(RegistryKey& rKey)
             {
                 AstServiceMember * decl = static_cast<AstServiceMember *>(*i);
                 writer.setReferenceData(referenceIndex++, decl->getDocumentation(), RT_REF_EXPORTS,
-                    (decl->isOptional() ? RT_ACCESS_OPTIONAL : RT_ACCESS_INVALID),
+                    (decl->isOptional() ? RTFieldAccess::OPTIONAL : RTFieldAccess::INVALID),
                     OStringToOUString(decl->getRealService()->getRelativName(),
                                            RTL_TEXTENCODING_UTF8));
             }
@@ -279,7 +279,7 @@ bool AstService::dump(RegistryKey& rKey)
             {
                 AstObserves * decl = static_cast<AstObserves *>(*i);
                 writer.setReferenceData(referenceIndex++, decl->getDocumentation(), RT_REF_OBSERVES,
-                    RT_ACCESS_INVALID,
+                    RTFieldAccess::INVALID,
                     OStringToOUString( decl->getRealInterface()->getRelativName(),
                                             RTL_TEXTENCODING_UTF8));
                 break;
@@ -289,7 +289,7 @@ bool AstService::dump(RegistryKey& rKey)
             {
                 AstNeeds * decl = static_cast<AstNeeds *>(*i);
                 writer.setReferenceData( referenceIndex++, decl->getDocumentation(), RT_REF_NEEDS,
-                    RT_ACCESS_INVALID,
+                    RTFieldAccess::INVALID,
                     OStringToOUString( decl->getRealService()->getRelativName(),
                                             RTL_TEXTENCODING_UTF8));
                 break;
@@ -326,46 +326,46 @@ bool AstService::dump(RegistryKey& rKey)
 bool AstAttribute::dumpBlob(
     typereg::Writer & rBlob, sal_uInt16 index, sal_uInt16 * methodIndex)
 {
-    RTFieldAccess accessMode = RT_ACCESS_INVALID;
+    RTFieldAccess accessMode = RTFieldAccess::INVALID;
 
     if (isReadonly())
     {
-        accessMode |= RT_ACCESS_READONLY;
+        accessMode |= RTFieldAccess::READONLY;
     } else
     {
-        accessMode |= RT_ACCESS_READWRITE;
+        accessMode |= RTFieldAccess::READWRITE;
     }
     if (isOptional())
     {
-        accessMode |= RT_ACCESS_OPTIONAL;
+        accessMode |= RTFieldAccess::OPTIONAL;
     }
     if (isBound())
     {
-        accessMode |= RT_ACCESS_BOUND;
+        accessMode |= RTFieldAccess::BOUND;
     }
     if (isMayBeVoid())
     {
-        accessMode |= RT_ACCESS_MAYBEVOID;
+        accessMode |= RTFieldAccess::MAYBEVOID;
     }
     if (isConstrained())
     {
-        accessMode |= RT_ACCESS_CONSTRAINED;
+        accessMode |= RTFieldAccess::CONSTRAINED;
     }
     if (isTransient())
     {
-        accessMode |= RT_ACCESS_TRANSIENT;
+        accessMode |= RTFieldAccess::TRANSIENT;
     }
     if (isMayBeAmbiguous())
     {
-        accessMode |= RT_ACCESS_MAYBEAMBIGUOUS;
+        accessMode |= RTFieldAccess::MAYBEAMBIGUOUS;
     }
     if (isMayBeDefault())
     {
-        accessMode |= RT_ACCESS_MAYBEDEFAULT;
+        accessMode |= RTFieldAccess::MAYBEDEFAULT;
     }
     if (isRemoveable())
     {
-        accessMode |= RT_ACCESS_REMOVABLE;
+        accessMode |= RTFieldAccess::REMOVABLE;
     }
 
     OUString name(OStringToOUString(getLocalName(), RTL_TEXTENCODING_UTF8));
diff --git a/idlc/source/astinterface.cxx b/idlc/source/astinterface.cxx
index 579ca0ac3a28..5941fa3e64d9 100644
--- a/idlc/source/astinterface.cxx
+++ b/idlc/source/astinterface.cxx
@@ -207,7 +207,7 @@ bool AstInterface::dump(RegistryKey& rKey)
         if (i->isOptional()) {
             aBlob.setReferenceData(
                 referenceIndex++, i->getDocumentation(), RT_REF_SUPPORTS,
-                RT_ACCESS_OPTIONAL,
+                RTFieldAccess::OPTIONAL,
                 OStringToOUString(
                     i->getInterface()->getRelativName(),
                     RTL_TEXTENCODING_UTF8));
diff --git a/idlc/source/aststruct.cxx b/idlc/source/aststruct.cxx
index 2b150e1e6aa3..49831731e97d 100644
--- a/idlc/source/aststruct.cxx
+++ b/idlc/source/aststruct.cxx
@@ -129,10 +129,10 @@ bool AstStruct::dump(RegistryKey& rKey)
             if ( pDecl->getNodeType() == NT_member )
             {
                 pMember = static_cast<AstMember*>(pDecl);
-                RTFieldAccess flags = RT_ACCESS_READWRITE;
+                RTFieldAccess flags = RTFieldAccess::READWRITE;
                 OString typeName;
                 if (pMember->getType()->getNodeType() == NT_type_parameter) {
-                    flags |= RT_ACCESS_PARAMETERIZED_TYPE;
+                    flags |= RTFieldAccess::PARAMETERIZED_TYPE;
                     typeName = pMember->getType()->getLocalName();
                 } else {
                     typeName = pMember->getType()->getRelativName();
@@ -153,7 +153,7 @@ bool AstStruct::dump(RegistryKey& rKey)
          i != m_typeParameters.end(); ++i)
     {
         aBlob.setReferenceData(
-            index++, emptyStr, RT_REF_TYPE_PARAMETER, RT_ACCESS_INVALID,
+            index++, emptyStr, RT_REF_TYPE_PARAMETER, RTFieldAccess::INVALID,
             OStringToOUString(
                 (*i)->getLocalName(), RTL_TEXTENCODING_UTF8));
     }
diff --git a/include/registry/reflread.hxx b/include/registry/reflread.hxx
index a26df02ecd3c..fddb072a7b69 100644
--- a/include/registry/reflread.hxx
+++ b/include/registry/reflread.hxx
@@ -297,7 +297,7 @@ public:
 
     /** returns the access mode of the reference specified by index.
 
-        The only valid value is RT_ACCESS_OPTIONAL in the context of
+        The only valid value is RTFieldAccess::OPTIONAL in the context of
         references.
         @param index indicates the reference.
      */
diff --git a/include/registry/reflwrit.hxx b/include/registry/reflwrit.hxx
index 75bff949daf5..57551dfbf703 100644
--- a/include/registry/reflwrit.hxx
+++ b/include/registry/reflwrit.hxx
@@ -216,7 +216,7 @@ public:
                                     const rtl::OUString&  name,
                                     RTReferenceType             refType,
                                     const rtl::OUString&  doku,
-                                    RTFieldAccess               access = RT_ACCESS_INVALID);
+                                    RTFieldAccess               access = RTFieldAccess::INVALID);
 
 protected:
 
diff --git a/include/registry/types.h b/include/registry/types.h
index e28d7dbc480b..dcc1152ab11b 100644
--- a/include/registry/types.h
+++ b/include/registry/types.h
@@ -21,6 +21,7 @@
 #define INCLUDED_REGISTRY_TYPES_H
 
 #include <sal/types.h>
+#include <o3tl/typed_flags_set.hxx>
 
 #ifdef __cplusplus
 extern "C" {
@@ -114,77 +115,82 @@ enum RTTypeClass {
     Fields in a type blob are used for different types.  Among others they were
     used for properties of services and these properties can have several flags.
 
-    @see RT_ACCESS_INVALID
-    @see RT_ACCESS_READONLY
-    @see RT_ACCESS_OPTIONAL
-    @see RT_ACCESS_MAYBEVOID
-    @see RT_ACCESS_BOUND
-    @see RT_ACCESS_CONSTRAINED
-    @see RT_ACCESS_TRANSIENT
-    @see RT_ACCESS_MAYBEAMBIGUOUS
-    @see RT_ACCESS_MAYBEDEFAULT
-    @see RT_ACCESS_REMOVABLE
-    @see RT_ACCESS_ATTRIBUTE
-    @see RT_ACCESS_PROPERTY
-    @see RT_ACCESS_CONST
-    @see RT_ACCESS_READWRITE
-    @see RT_ACCESS_DEFAULT
-    @see RT_ACCESS_PARAMETERIZED_TYPE
-    @see RT_ACCESS_PUBLISHED
+    @see RTFieldAccess::INVALID
+    @see RTFieldAccess::READONLY
+    @see RTFieldAccess::OPTIONAL
+    @see RTFieldAccess::MAYBEVOID
+    @see RTFieldAccess::BOUND
+    @see RTFieldAccess::CONSTRAINED
+    @see RTFieldAccess::TRANSIENT
+    @see RTFieldAccess::MAYBEAMBIGUOUS
+    @see RTFieldAccess::MAYBEDEFAULT
+    @see RTFieldAccess::REMOVABLE
+    @see RTFieldAccess::ATTRIBUTE
+    @see RTFieldAccess::PROPERTY
+    @see RTFieldAccess::CONST
+    @see RTFieldAccess::READWRITE
+    @see RTFieldAccess::DEFAULT
+    @see RTFieldAccess::PARAMETERIZED_TYPE
+    @see RTFieldAccess::PUBLISHED
  */
-typedef sal_uInt16 RTFieldAccess;
-
-/// specifies a unknown flag
-#define RT_ACCESS_INVALID 0x0000
-/// specifies a readonly property/attribute
-#define RT_ACCESS_READONLY 0x0001
-/// specifies a property as optional that means that it must not be implemented.
-#define RT_ACCESS_OPTIONAL 0x0002
-/// @see com::sun::star::beans::PropertyAttribute
-#define RT_ACCESS_MAYBEVOID 0x0004
-/// @see com::sun::star::beans::PropertyAttribute
-#define RT_ACCESS_BOUND 0x0008
-/// @see com::sun::star::beans::PropertyAttribute
-#define RT_ACCESS_CONSTRAINED 0x0010
-/// @see com::sun::star::beans::PropertyAttribute
-#define RT_ACCESS_TRANSIENT 0x0020
-/// @see com::sun::star::beans::PropertyAttribute
-#define RT_ACCESS_MAYBEAMBIGUOUS 0x0040
-/// @see com::sun::star::beans::PropertyAttribute
-#define RT_ACCESS_MAYBEDEFAULT 0x0080
-/// @see com::sun::star::beans::PropertyAttribute
-#define RT_ACCESS_REMOVABLE 0x0100
-/// @see com::sun::star::beans::PropertyAttribute
-#define RT_ACCESS_ATTRIBUTE 0x0200
-/// specifies that the field is a property
-#define RT_ACCESS_PROPERTY 0x0400
-/// specifies that the field is a constant or enum value
-#define RT_ACCESS_CONST 0x0800
-/// specifies that the property/attribute has read/write access
-#define RT_ACCESS_READWRITE 0x1000
-/// only to describe a union default label
-#define RT_ACCESS_DEFAULT 0x2000
-
-/**
-   Indicates that a member of a polymorphic struct type template is of a
-   parameterized type.
-
-   Only valid for fields that represent members of polymorphic struct type
-   templates.
-
-   @since UDK 3.2.0
- */
-#define RT_ACCESS_PARAMETERIZED_TYPE 0x4000
+enum class RTFieldAccess
+{
+    NONE        = 0x0000,
+    /// specifies a unknown flag
+    INVALID     = 0x0000,
+    /// specifies a readonly property/attribute
+    READONLY    = 0x0001,
+    /// specifies a property as optional that means that it must not be implemented.
+    OPTIONAL    = 0x0002,
+    /// @see com::sun::star::beans::PropertyAttribute
+    MAYBEVOID   = 0x0004,
+    /// @see com::sun::star::beans::PropertyAttribute
+    BOUND       = 0x0008,
+    /// @see com::sun::star::beans::PropertyAttribute
+    CONSTRAINED = 0x0010,
+    /// @see com::sun::star::beans::PropertyAttribute
+    TRANSIENT   = 0x0020,
+    /// @see com::sun::star::beans::PropertyAttribute
+    MAYBEAMBIGUOUS = 0x0040,
+    /// @see com::sun::star::beans::PropertyAttribute
+    MAYBEDEFAULT = 0x0080,
+    /// @see com::sun::star::beans::PropertyAttribute
+    REMOVABLE   = 0x0100,
+    /// @see com::sun::star::beans::PropertyAttribute
+    ATTRIBUTE   = 0x0200,
+    /// specifies that the field is a property
+    PROPERTY    = 0x0400,
+    /// specifies that the field is a constant or enum value
+    CONST       = 0x0800,
+    /// specifies that the property/attribute has read/write access
+    READWRITE   = 0x1000,
+    /// only to describe a union default label
+    DEFAULT     = 0x2000,
+    /**
+       Indicates that a member of a polymorphic struct type template is of a
+       parameterized type.
 
-/**
-   Flag for published individual constants.
+       Only valid for fields that represent members of polymorphic struct type
+       templates.
 
-   Used in combination with RT_ACCESS_CONST for individual constants (which are
-   not members of constant groups).
+       @since UDK 3.2.0
+     */
+    PARAMETERIZED_TYPE = 0x4000,
+    /**
+       Flag for published individual constants.
 
-   @since UDK 3.2.0
- */
-#define RT_ACCESS_PUBLISHED 0x8000
+       Used in combination with RTFieldAccess::CONST for individual constants (which are
+       not members of constant groups).
+
+       @since UDK 3.2.0
+     */
+    PUBLISHED = 0x8000,
+
+};
+namespace o3tl
+{
+    template<> struct typed_flags<RTFieldAccess> : is_typed_flags<RTFieldAccess, 0xffff> {};
+}
 
 /** specifies the type of a field value.
 
diff --git a/registry/source/reflread.cxx b/registry/source/reflread.cxx
index 15a9d0f4c25c..5b1c58c8dbef 100644
--- a/registry/source/reflread.cxx
+++ b/registry/source/reflread.cxx
@@ -681,7 +681,7 @@ const sal_Char* FieldList::getFieldType(sal_uInt16 index)
 
 RTFieldAccess FieldList::getFieldAccess(sal_uInt16 index)
 {
-    RTFieldAccess aAccess = RT_ACCESS_INVALID;
+    RTFieldAccess aAccess = RTFieldAccess::INVALID;
 
     if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
     {
@@ -878,7 +878,7 @@ const sal_Char* ReferenceList::getReferenceDoku(sal_uInt16 index)
 
 RTFieldAccess ReferenceList::getReferenceAccess(sal_uInt16 index)
 {
-    RTFieldAccess aAccess = RT_ACCESS_INVALID;
+    RTFieldAccess aAccess = RTFieldAccess::INVALID;
 
     if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
     {
@@ -1519,7 +1519,7 @@ RTFieldAccess TYPEREG_CALLTYPE typereg_reader_getFieldFlags(void * hEntry, sal_u
 {
     TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
 
-    if (pEntry == NULL) return RT_ACCESS_INVALID;
+    if (pEntry == NULL) return RTFieldAccess::INVALID;
 
     return pEntry->m_pFields->getFieldAccess(index);
 }
@@ -1815,7 +1815,7 @@ RTFieldAccess TYPEREG_CALLTYPE typereg_reader_getReferenceFlags(void * hEntry, s
 {
     TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
 
-    if (pEntry == NULL) return RT_ACCESS_INVALID;
+    if (pEntry == NULL) return RTFieldAccess::INVALID;
 
     return pEntry->m_pReferences->getReferenceAccess(index);
 }
diff --git a/registry/source/reflwrit.cxx b/registry/source/reflwrit.cxx
index 49beeb0d325c..426911bce518 100644
--- a/registry/source/reflwrit.cxx
+++ b/registry/source/reflwrit.cxx
@@ -351,7 +351,7 @@ public:
 };
 
 FieldEntry::FieldEntry()
-    : m_access(RT_ACCESS_INVALID)
+    : m_access(RTFieldAccess::INVALID)
     , m_constValueType(RT_TYPE_NONE)
 {
 }
@@ -481,7 +481,7 @@ public:
 
 ReferenceEntry::ReferenceEntry()
     : m_type(RT_REF_INVALID)
-    , m_access(RT_ACCESS_INVALID)
+    , m_access(RTFieldAccess::INVALID)
 {
 }
 
@@ -856,7 +856,7 @@ void TypeWriter::createBlop()
             cpIndexDoku2 = 0;
             cpIndexFileName2 = 0;
 
-            pBuffer += writeUINT16(pBuffer, m_fields[i].m_access);
+            pBuffer += writeUINT16(pBuffer, static_cast<sal_uInt16>(m_fields[i].m_access));
 
             if (!m_fields[i].m_name.isEmpty())
             {
@@ -1060,7 +1060,7 @@ void TypeWriter::createBlop()
             }
             pBuffer += writeUINT16(pBuffer, cpIndexDoku2);
 
-            pBuffer += writeUINT16(pBuffer, m_references[i].m_access);
+            pBuffer += writeUINT16(pBuffer, static_cast<sal_uInt16>(m_references[i].m_access));
         }
     }
 
diff --git a/registry/source/regimpl.cxx b/registry/source/regimpl.cxx
index a1ed1ffba133..09afcc0c5cb7 100644
--- a/registry/source/regimpl.cxx
+++ b/registry/source/regimpl.cxx
@@ -73,7 +73,7 @@ void printString(OUString const & s) {
 void printFieldOrReferenceFlag(
     RTFieldAccess * flags, RTFieldAccess flag, char const * name, bool * first)
 {
-    if ((*flags & flag) != 0) {
+    if ((*flags & flag) != RTFieldAccess::NONE) {
         if (!*first) {
             printf("|");
         }
@@ -84,39 +84,39 @@ void printFieldOrReferenceFlag(
 }
 
 void printFieldOrReferenceFlags(RTFieldAccess flags) {
-    if (flags == 0) {
+    if (flags == RTFieldAccess::NONE) {
         printf("none");
     } else {
         bool first = true;
         printFieldOrReferenceFlag(
-            &flags, RT_ACCESS_READONLY, "readonly", &first);
+            &flags, RTFieldAccess::READONLY, "readonly", &first);
         printFieldOrReferenceFlag(
-            &flags, RT_ACCESS_OPTIONAL, "optional", &first);
+            &flags, RTFieldAccess::OPTIONAL, "optional", &first);
         printFieldOrReferenceFlag(
-            &flags, RT_ACCESS_MAYBEVOID, "maybevoid", &first);
-        printFieldOrReferenceFlag(&flags, RT_ACCESS_BOUND, "bound", &first);
+            &flags, RTFieldAccess::MAYBEVOID, "maybevoid", &first);
+        printFieldOrReferenceFlag(&flags, RTFieldAccess::BOUND, "bound", &first);
         printFieldOrReferenceFlag(
-            &flags, RT_ACCESS_CONSTRAINED, "constrained", &first);
+            &flags, RTFieldAccess::CONSTRAINED, "constrained", &first);
         printFieldOrReferenceFlag(
-            &flags, RT_ACCESS_TRANSIENT, "transient", &first);
+            &flags, RTFieldAccess::TRANSIENT, "transient", &first);
         printFieldOrReferenceFlag(
-            &flags, RT_ACCESS_MAYBEAMBIGUOUS, "maybeambiguous", &first);
+            &flags, RTFieldAccess::MAYBEAMBIGUOUS, "maybeambiguous", &first);
         printFieldOrReferenceFlag(
-            &flags, RT_ACCESS_MAYBEDEFAULT, "maybedefault", &first);
+            &flags, RTFieldAccess::MAYBEDEFAULT, "maybedefault", &first);
         printFieldOrReferenceFlag(
-            &flags, RT_ACCESS_REMOVABLE, "removable", &first);
+            &flags, RTFieldAccess::REMOVABLE, "removable", &first);
         printFieldOrReferenceFlag(
-            &flags, RT_ACCESS_ATTRIBUTE, "attribute", &first);
+            &flags, RTFieldAccess::ATTRIBUTE, "attribute", &first);
         printFieldOrReferenceFlag(
-            &flags, RT_ACCESS_PROPERTY, "property", &first);
-        printFieldOrReferenceFlag(&flags, RT_ACCESS_CONST, "const", &first);
+            &flags, RTFieldAccess::PROPERTY, "property", &first);
+        printFieldOrReferenceFlag(&flags, RTFieldAccess::CONST, "const", &first);
         printFieldOrReferenceFlag(
-            &flags, RT_ACCESS_READWRITE, "readwrite", &first);
+            &flags, RTFieldAccess::READWRITE, "readwrite", &first);
         printFieldOrReferenceFlag(
-            &flags, RT_ACCESS_PARAMETERIZED_TYPE, "parameterized type", &first);
+            &flags, RTFieldAccess::PARAMETERIZED_TYPE, "parameterized type", &first);
         printFieldOrReferenceFlag(
-            &flags, RT_ACCESS_PUBLISHED, "published", &first);
-        if (flags != 0) {
+            &flags, RTFieldAccess::PUBLISHED, "published", &first);
+        if (flags != RTFieldAccess::NONE) {
             if (!first) {
                 printf("|");
             }
diff --git a/registry/test/testregcpp.cxx b/registry/test/testregcpp.cxx
index 514accf99822..e7853c36b81e 100644
--- a/registry/test/testregcpp.cxx
+++ b/registry/test/testregcpp.cxx
@@ -65,60 +65,60 @@ void test_coreReflection()
         writer.setFieldData(0, OUString("aConstBool"),
                             OUString("boolean"),
                             OUString("ich bin ein boolean"),
-                            OUString("DummyFile"), RT_ACCESS_CONST, aConst);
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
         aConst.m_type = RT_TYPE_BYTE;
         aConst.m_value.aByte = 127;
         writer.setFieldData(1, OUString("aConstByte"),
                             OUString("byte"),
                             OUString("ich bin ein byte"),
-                            OUString("DummyFile"),  RT_ACCESS_CONST, aConst);
+                            OUString("DummyFile"),  RTFieldAccess::CONST, aConst);
         aConst.m_type = RT_TYPE_INT16;
         aConst.m_value.aShort = -10;
         writer.setFieldData(2, OUString("aConstShort"),
                             OUString("short"),
                             OUString("ich bin ein short"),
-                            OUString("DummyFile"),  RT_ACCESS_CONST, aConst);
+                            OUString("DummyFile"),  RTFieldAccess::CONST, aConst);
         aConst.m_type = RT_TYPE_UINT16;
         aConst.m_value.aUShort = 10;
         writer.setFieldData(3, OUString("aConstUShort"),
                             OUString("unsigned short"),
                             OUString("ich bin ein unsigned short"),
-                            OUString("DummyFile"), RT_ACCESS_CONST, aConst);
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
         aConst.m_type = RT_TYPE_INT32;
         aConst.m_value.aLong = -100000;
         writer.setFieldData(4, OUString("aConstLong"),
                             OUString("long"),
                             OUString("ich bin ein long"),
-                            OUString("DummyFile"), RT_ACCESS_CONST, aConst);
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
         aConst.m_type = RT_TYPE_UINT32;
         aConst.m_value.aULong = 100000;
         writer.setFieldData(5, OUString("aConstULong"),
                             OUString("unsigned long"),
                             OUString("ich bin ein unsigned long"),
-                            OUString("DummyFile"), RT_ACCESS_CONST, aConst);
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
         aConst.m_type = RT_TYPE_INT64;
         aConst.m_value.aHyper = -100000000;
         writer.setFieldData(6, OUString("aConstHyper"),
                             OUString("hyper"),
                             OUString("ich bin ein hyper"),
-                            OUString("DummyFile"), RT_ACCESS_CONST, aConst);
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
         aConst.m_type = RT_TYPE_UINT64;
         aConst.m_value.aUHyper = 100000000;
         writer.setFieldData(7, OUString("aConstULong"),
                             OUString("unsigned long"),
                             OUString("ich bin ein unsigned long"),
-                            OUString("DummyFile"), RT_ACCESS_CONST, aConst);
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
         aConst.m_type = RT_TYPE_FLOAT;
         aConst.m_value.aFloat = -2e-10f;
         writer.setFieldData(8, OUString("aConstFloat"),
                             OUString("float"),
                             OUString("ich bin ein float"),
-                            OUString("DummyFile"), RT_ACCESS_CONST, aConst);
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
         aConst.m_type = RT_TYPE_DOUBLE;
         aConst.m_value.aDouble = -2e-100; writer.setFieldData(9, OUString("aConstDouble"),
                                                               OUString("double"),
                                                               OUString("ich bin ein double"),
-                                                              OUString("DummyFile"), RT_ACCESS_CONST, aConst);
+                                                              OUString("DummyFile"), RTFieldAccess::CONST, aConst);
         aConst.m_type = RT_TYPE_STRING;
         OUString tmpStr("dies ist ein unicode string");
         aConst.m_value.aString = tmpStr.getStr();
@@ -126,7 +126,7 @@ void test_coreReflection()
         writer.setFieldData(10, OUString("aConstString"),
                             OUString("string"),
                             OUString("ich bin ein string"),
-                            OUString("DummyFile"), RT_ACCESS_CONST, aConst);
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
 
         const sal_uInt8* pBlop = writer.getBlop();
         sal_uInt32      aBlopSize = writer.getBlopSize();
@@ -167,13 +167,13 @@ void test_coreReflection()
 
         writer.setFieldData(0, OUString("asal_uInt32"),
                             OUString("unsigned long"),
-                            OUString(), OUString(), RT_ACCESS_READWRITE);
+                            OUString(), OUString(), RTFieldAccess::READWRITE);
         writer.setFieldData(1, OUString("aXInterface"),
                             OUString("stardiv/uno/XInterface"),
-                            OUString(), OUString(), RT_ACCESS_READWRITE);
+                            OUString(), OUString(), RTFieldAccess::READWRITE);
         writer.setFieldData(2, OUString("aSequence"),
                             OUString("[]ModuleA/EnumA"),
-                            OUString(), OUString(), RT_ACCESS_READWRITE);
+                            OUString(), OUString(), RTFieldAccess::READWRITE);
 
         const sal_uInt8* pBlop = writer.getBlop();
         sal_uInt32      aBlopSize = writer.getBlopSize();
@@ -196,11 +196,11 @@ void test_coreReflection()
 
         writer.setFieldData(0, OUString("ENUM_VAL_1"),
                             OUString(), OUString("ich bin ein enum value"),
-                            OUString(), RT_ACCESS_CONST, aConst);
+                            OUString(), RTFieldAccess::CONST, aConst);
 
         aConst.m_value.aULong = 10;
         writer.setFieldData(1, OUString("ENUM_VAL_2"),
-                            OUString(), OUString(), OUString(), RT_ACCESS_CONST, aConst);
+                            OUString(), OUString(), OUString(), RTFieldAccess::CONST, aConst);
 
         const sal_uInt8* pBlop = writer.getBlop();
         sal_uInt32      aBlopSize = writer.getBlopSize();
@@ -222,17 +222,17 @@ void test_coreReflection()
         writer.setFileName(OUString("DummyFile"));
 
         writer.setFieldData(0, OUString("aString"),
-                            OUString("string"), OUString(), OUString(), RT_ACCESS_READWRITE);
+                            OUString("string"), OUString(), OUString(), RTFieldAccess::READWRITE);
         writer.setFieldData(1, OUString("aStruct"),
                             OUString("ModuleA/StructA"),
-                            OUString(), OUString(), RT_ACCESS_READONLY);
+                            OUString(), OUString(), RTFieldAccess::READONLY);
         writer.setFieldData(2, OUString("aEnum"),
-                            OUString("ModuleA/EnumA"), OUString(), OUString(), RT_ACCESS_BOUND);
+                            OUString("ModuleA/EnumA"), OUString(), OUString(), RTFieldAccess::BOUND);
         aConst.m_type = RT_TYPE_UINT16;
         aConst.m_value.aUShort = 12;
         writer.setFieldData(3, OUString("aConstUShort"),
                             OUString("unsigned short"), OUString(),
-                            OUString("DummyFile"), RT_ACCESS_CONST, aConst);
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
 
         writer.setMethodData(0, OUString("methodA"),
                              OUString("double"), RT_MODE_TWOWAY, 2, 1,
@@ -278,7 +278,7 @@ void test_coreReflection()
         writer.setFieldData(0, OUString("aSource"),
                             OUString("stardiv/uno/XInterface"),
                             OUString("ich bin ein interface member"),
-                            OUString(), RT_ACCESS_READWRITE);
+                            OUString(), RTFieldAccess::READWRITE);
 
         const sal_uInt8* pBlop = writer.getBlop();
         sal_uInt32      aBlopSize = writer.getBlopSize();
@@ -297,11 +297,11 @@ void test_coreReflection()
         writer.setFieldData(0, OUString("aProperty"),
                             OUString("stardiv/uno/XInterface"),
                             OUString("ich bin eine property"),
-                            OUString(), RT_ACCESS_READWRITE);
+                            OUString(), RTFieldAccess::READWRITE);
 
         writer.setReferenceData(0, OUString("ModuleA/XInterfaceA"), RT_REF_SUPPORTS,
                                 OUString("Hallo ich eine Reference auf ein supported interface"),
-                                RT_ACCESS_OPTIONAL);
+                                RTFieldAccess::OPTIONAL);
         writer.setReferenceData(1, OUString("ModuleA/XInterfaceA"), RT_REF_OBSERVES,
                                 OUString("Hallo ich eine Reference auf ein observed interface"));
         writer.setReferenceData(2, OUString("ModuleA/ServiceB"), RT_REF_EXPORTS,
@@ -345,19 +345,19 @@ void test_coreReflection()
         writer.setFieldData(0, OUString("ConstantsA_aConstBool"),
                             OUString("boolean"),
                             OUString("ich bin ein boolean"),
-                            OUString("DummyFile"), RT_ACCESS_CONST, aConst);
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
         aConst.m_type = RT_TYPE_BYTE;
         aConst.m_value.aByte = 127;
         writer.setFieldData(1, OUString("ConstantsA_aConstByte"),
                             OUString("byte"),
                             OUString("ich bin ein byte"),
-                            OUString("DummyFile"),  RT_ACCESS_CONST, aConst);
+                            OUString("DummyFile"),  RTFieldAccess::CONST, aConst);
         aConst.m_type = RT_TYPE_INT16;
         aConst.m_value.aShort = -10;
         writer.setFieldData(2, OUString("ConstantsA_aConstShort"),
                             OUString("short"),
                             OUString("ich bin ein short"),
-                            OUString("DummyFile"),  RT_ACCESS_CONST, aConst);
+                            OUString("DummyFile"),  RTFieldAccess::CONST, aConst);
 
         const sal_uInt8* pBlop = writer.getBlop();
         sal_uInt32      aBlopSize = writer.getBlopSize();
diff --git a/registry/tools/regcompare.cxx b/registry/tools/regcompare.cxx
index def055ab7ced..2018f57e40e0 100644
--- a/registry/tools/regcompare.cxx
+++ b/registry/tools/regcompare.cxx
@@ -305,59 +305,59 @@ static char const * getTypeClass(RTTypeClass typeClass)
 static OString getFieldAccess(RTFieldAccess fieldAccess)
 {
     OString ret;
-    if ( (fieldAccess & RT_ACCESS_INVALID) == RT_ACCESS_INVALID )
+    if ( (fieldAccess & RTFieldAccess::INVALID) == RTFieldAccess::INVALID )
     {
         ret += OString("INVALID");
     }
-    if ( (fieldAccess & RT_ACCESS_READONLY) == RT_ACCESS_READONLY )
+    if ( (fieldAccess & RTFieldAccess::READONLY) == RTFieldAccess::READONLY )
     {
         ret += OString(ret.isEmpty() ? "READONLY" : ",READONLY");
     }
-    if ( (fieldAccess & RT_ACCESS_OPTIONAL) == RT_ACCESS_OPTIONAL )
+    if ( (fieldAccess & RTFieldAccess::OPTIONAL) == RTFieldAccess::OPTIONAL )
     {
         ret += OString(ret.isEmpty() ? "OPTIONAL" : ",OPTIONAL");
     }
-    if ( (fieldAccess & RT_ACCESS_MAYBEVOID) == RT_ACCESS_MAYBEVOID )
+    if ( (fieldAccess & RTFieldAccess::MAYBEVOID) == RTFieldAccess::MAYBEVOID )
     {
         ret += OString(ret.isEmpty() ? "MAYBEVOID" : ",MAYBEVOID");
     }
-    if ( (fieldAccess & RT_ACCESS_BOUND) == RT_ACCESS_BOUND )
+    if ( (fieldAccess & RTFieldAccess::BOUND) == RTFieldAccess::BOUND )
     {
         ret += OString(ret.isEmpty() ? "BOUND" : ",BOUND");
     }
-    if ( (fieldAccess & RT_ACCESS_CONSTRAINED) == RT_ACCESS_CONSTRAINED )
+    if ( (fieldAccess & RTFieldAccess::CONSTRAINED) == RTFieldAccess::CONSTRAINED )
     {
         ret += OString(ret.isEmpty() ? "CONSTRAINED" : ",CONSTRAINED");
     }
-    if ( (fieldAccess & RT_ACCESS_TRANSIENT) == RT_ACCESS_TRANSIENT )
+    if ( (fieldAccess & RTFieldAccess::TRANSIENT) == RTFieldAccess::TRANSIENT )
     {
         ret += OString(ret.isEmpty() ? "TRANSIENT" : ",TRANSIENT");
     }
-    if ( (fieldAccess & RT_ACCESS_MAYBEAMBIGUOUS) == RT_ACCESS_MAYBEAMBIGUOUS )
+    if ( (fieldAccess & RTFieldAccess::MAYBEAMBIGUOUS) == RTFieldAccess::MAYBEAMBIGUOUS )
     {
         ret += OString(ret.isEmpty() ? "MAYBEAMBIGUOUS" : ",MAYBEAMBIGUOUS");
     }
-    if ( (fieldAccess & RT_ACCESS_MAYBEDEFAULT) == RT_ACCESS_MAYBEDEFAULT )
+    if ( (fieldAccess & RTFieldAccess::MAYBEDEFAULT) == RTFieldAccess::MAYBEDEFAULT )
     {
         ret += OString(ret.isEmpty() ? "MAYBEDEFAULT" : ",MAYBEDEFAULT");
     }
-    if ( (fieldAccess & RT_ACCESS_REMOVABLE) == RT_ACCESS_REMOVABLE )
+    if ( (fieldAccess & RTFieldAccess::REMOVABLE) == RTFieldAccess::REMOVABLE )
     {
         ret += OString(ret.isEmpty() ? "REMOVABLE" : ",REMOVABLE");
     }
-    if ( (fieldAccess & RT_ACCESS_ATTRIBUTE) == RT_ACCESS_ATTRIBUTE )
+    if ( (fieldAccess & RTFieldAccess::ATTRIBUTE) == RTFieldAccess::ATTRIBUTE )
     {
         ret += OString(ret.isEmpty() ? "ATTRIBUTE" : ",ATTRIBUTE");
     }
-    if ( (fieldAccess & RT_ACCESS_PROPERTY) == RT_ACCESS_PROPERTY )
+    if ( (fieldAccess & RTFieldAccess::PROPERTY) == RTFieldAccess::PROPERTY )
     {
         ret += OString(ret.isEmpty() ? "PROPERTY" : ",PROPERTY");
     }
-    if ( (fieldAccess & RT_ACCESS_CONST) == RT_ACCESS_CONST )
+    if ( (fieldAccess & RTFieldAccess::CONST) == RTFieldAccess::CONST )
     {
         ret += OString(ret.isEmpty() ? "CONST" : ",CONST");
     }
-    if ( (fieldAccess & RT_ACCESS_READWRITE) == RT_ACCESS_READWRITE )
+    if ( (fieldAccess & RTFieldAccess::READWRITE) == RTFieldAccess::READWRITE )
     {
         ret += OString(ret.isEmpty() ? "READWRITE" : ",READWRITE");
     }
@@ -1015,7 +1015,7 @@ static sal_uInt32 checkFieldsWithoutOrder(Options_Impl const & options,
         {
             if ( moreProps.find(j) == moreProps.end() )
             {
-                if ( (reader2.getFieldFlags(j) & RT_ACCESS_OPTIONAL) != RT_ACCESS_OPTIONAL )
+                if ( (reader2.getFieldFlags(j) & RTFieldAccess::OPTIONAL) != RTFieldAccess::OPTIONAL )
                 {
                     if ( options.forceOutput() )
                     {
@@ -1251,7 +1251,7 @@ static sal_uInt32 checkBlob(
                 {
                     if ( moreReferences.find(j) == moreReferences.end() )
                     {
-                        if ( (reader2.getReferenceFlags(j) & RT_ACCESS_OPTIONAL) != RT_ACCESS_OPTIONAL )
+                        if ( (reader2.getReferenceFlags(j) & RTFieldAccess::OPTIONAL) != RTFieldAccess::OPTIONAL )
                         {
                             if ( options.forceOutput() )
                             {
diff --git a/unoidl/source/legacyprovider.cxx b/unoidl/source/legacyprovider.cxx
index db042069ef86..7d10eb3cd5bd 100644
--- a/unoidl/source/legacyprovider.cxx
+++ b/unoidl/source/legacyprovider.cxx
@@ -300,8 +300,8 @@ rtl::Reference< Entity > readEntity(
                 attrs.push_back(
                     InterfaceTypeEntity::Attribute(
                         attrName, reader.getFieldTypeName(j).replace('/', '.'),
-                        (flags & RT_ACCESS_BOUND) != 0,
-                        (flags & RT_ACCESS_READONLY) != 0, getExcs, setExcs,
+                        bool(flags & RTFieldAccess::BOUND),
+                        bool(flags & RTFieldAccess::READONLY), getExcs, setExcs,
                         translateAnnotations(reader.getFieldDocumentation(j))));
             }
             std::vector< InterfaceTypeEntity::Method > meths;
@@ -422,9 +422,8 @@ rtl::Reference< Entity > readEntity(
                         PolymorphicStructTypeTemplateEntity::Member(
                             reader.getFieldName(j),
                             reader.getFieldTypeName(j).replace('/', '.'),
-                            ((reader.getFieldFlags(j)
-                              & RT_ACCESS_PARAMETERIZED_TYPE)
-                             != 0),
+                            bool(reader.getFieldFlags(j)
+                                 & RTFieldAccess::PARAMETERIZED_TYPE),
                             translateAnnotations(
                                 reader.getFieldDocumentation(j))));
                 }
@@ -514,8 +513,7 @@ rtl::Reference< Entity > readEntity(
                             reader.getReferenceDocumentation(j)));
                     switch (reader.getReferenceSort(j)) {
                     case RT_REF_EXPORTS:
-                        if ((reader.getReferenceFlags(j) & RT_ACCESS_OPTIONAL)
-                            == 0)
+                        if (!(reader.getReferenceFlags(j) & RTFieldAccess::OPTIONAL))
                         {
                             mandServs.push_back(base);
                         } else {
@@ -523,8 +521,7 @@ rtl::Reference< Entity > readEntity(
                         }
                         break;
                     case RT_REF_SUPPORTS:
-                        if ((reader.getReferenceFlags(j) & RT_ACCESS_OPTIONAL)
-                            == 0)
+                        if (!(reader.getReferenceFlags(j) & RTFieldAccess::OPTIONAL))
                         {
                             mandIfcs.push_back(base);
                         } else {
@@ -545,39 +542,39 @@ rtl::Reference< Entity > readEntity(
                 for (sal_uInt16 j = 0; j != n; ++j) {
                     RTFieldAccess acc = reader.getFieldFlags(j);
                     int attrs = 0;
-                    if ((acc & RT_ACCESS_READONLY) != 0) {
+                    if (acc & RTFieldAccess::READONLY) {
                         attrs |= AccumulationBasedServiceEntity::Property::
                             ATTRIBUTE_READ_ONLY;
                     }
-                    if ((acc & RT_ACCESS_OPTIONAL) != 0) {
+                    if (acc & RTFieldAccess::OPTIONAL) {
                         attrs |= AccumulationBasedServiceEntity::Property::
                             ATTRIBUTE_OPTIONAL;
                     }
-                    if ((acc & RT_ACCESS_MAYBEVOID) != 0) {
+                    if (acc & RTFieldAccess::MAYBEVOID) {
                         attrs |= AccumulationBasedServiceEntity::Property::
                             ATTRIBUTE_MAYBE_VOID;
                     }
-                    if ((acc & RT_ACCESS_BOUND) != 0) {
+                    if (acc & RTFieldAccess::BOUND) {
                         attrs |= AccumulationBasedServiceEntity::Property::
                             ATTRIBUTE_BOUND;
                     }
-                    if ((acc & RT_ACCESS_CONSTRAINED) != 0) {
+                    if (acc & RTFieldAccess::CONSTRAINED) {
                         attrs |= AccumulationBasedServiceEntity::Property::
                             ATTRIBUTE_CONSTRAINED;
                     }
-                    if ((acc & RT_ACCESS_TRANSIENT) != 0) {
+                    if (acc & RTFieldAccess::TRANSIENT) {
                         attrs |= AccumulationBasedServiceEntity::Property::
                             ATTRIBUTE_TRANSIENT;
                     }
-                    if ((acc & RT_ACCESS_MAYBEAMBIGUOUS) != 0) {
+                    if (acc & RTFieldAccess::MAYBEAMBIGUOUS) {
                         attrs |= AccumulationBasedServiceEntity::Property::
                             ATTRIBUTE_MAYBE_AMBIGUOUS;
                     }
-                    if ((acc & RT_ACCESS_MAYBEDEFAULT) != 0) {
+                    if (acc & RTFieldAccess::MAYBEDEFAULT) {
                         attrs |= AccumulationBasedServiceEntity::Property::
                             ATTRIBUTE_MAYBE_DEFAULT;
                     }
-                    if ((acc & RT_ACCESS_REMOVABLE) != 0) {
+                    if (acc & RTFieldAccess::REMOVABLE) {
                         attrs |= AccumulationBasedServiceEntity::Property::
                             ATTRIBUTE_REMOVABLE;
                     }