iox-#846 Use upper camel case for enums tags in filesystem.hpp

Author: elBoberido

doc/website/FAQ.md

@@ -83,7 +83,7 @@ SharedMemory still there, doing an unlink of /root
 Reserving 27902400 bytes in the shared memory [/root]
 While setting the acquired shared memory to zero a fatal SIGBUS signal appeared
 caused by memset. The shared memory object with the following properties
-[ name = /root, sizeInBytes = 27902400, access mode = AccessMode::READ_WRITE,
+[ name = /root, sizeInBytes = 27902400, access mode = AccessMode::ReadWrite,
 ownership = OwnerShip::MINE, baseAddressHint = (nil), permissions = 0 ] maybe
 requires more memory than it is currently available in the system.
 ```

doc/website/release-notes/iceoryx-unreleased.md

@@ -309,7 +309,7 @@
     iox::optional<iox::NamedSemaphore> semaphore;
     auto result = iox::NamedSemaphoreBuilder()
                     .name("mySemaphoreName")
-                    .openMode(iox::OpenMode::OPEN_OR_CREATE)
+                    .openMode(iox::OpenMode::OpenOrCreate)
                     .permissions(iox::perms::owner_all)
                     .initialValue(0U)
                     .create(semaphore);

iceoryx_hoofs/filesystem/include/iox/detail/filesystem.inl

@@ -29,7 +29,7 @@ inline bool isValidPathEntry(const iox::string<StringCapacity>& name,
 
     if ((name == currentDirectory) || (name == parentDirectory))
     {
-        return relativePathComponents == RelativePathComponents::ACCEPT;
+        return relativePathComponents == RelativePathComponents::Accept;
     }
 
     const auto nameSize = name.size();
@@ -75,7 +75,7 @@ inline bool isValidFileName(const iox::string<StringCapacity>& name) noexcept
     }
 
     // check if the file contains only valid characters
-    return isValidPathEntry(name, RelativePathComponents::REJECT);
+    return isValidPathEntry(name, RelativePathComponents::Reject);
 }
 
 template <uint64_t StringCapacity>
@@ -160,7 +160,7 @@ inline bool isValidPathToDirectory(const iox::string<StringCapacity>& name) noex
         }
         else // we reached the last entry, if its a valid file name the path is valid
         {
-            return isValidPathEntry(remaining, RelativePathComponents::ACCEPT);
+            return isValidPathEntry(remaining, RelativePathComponents::Accept);
         }
     }
 
@@ -191,32 +191,32 @@ inline constexpr const char* asStringLiteral(const OpenMode mode) noexcept
 {
     switch (mode)
     {
-    case OpenMode::EXCLUSIVE_CREATE:
-        return "OpenMode::EXCLUSIVE_CREATE";
-    case OpenMode::PURGE_AND_CREATE:
-        return "OpenMode::PURGE_AND_CREATE";
-    case OpenMode::OPEN_OR_CREATE:
-        return "OpenMode::OPEN_OR_CREATE";
-    case OpenMode::OPEN_EXISTING:
-        return "OpenMode::OPEN_EXISTING";
+    case OpenMode::ExclusiveCreate:
+        return "OpenMode::ExclusiveCreate";
+    case OpenMode::PurgeAndCreate:
+        return "OpenMode::PurgeAndCreate";
+    case OpenMode::OpenOrCreate:
+        return "OpenMode::OpenOrCreate";
+    case OpenMode::OpenExisting:
+        return "OpenMode::OpenExisting";
     }
 
-    return "OpenMode::UNDEFINED_VALUE";
+    return "OpenMode::UndefinedValue";
 }
 
 inline constexpr const char* asStringLiteral(const AccessMode mode) noexcept
 {
     switch (mode)
     {
-    case AccessMode::READ_ONLY:
-        return "AccessMode::READ_ONLY";
-    case AccessMode::READ_WRITE:
-        return "AccessMode::READ_WRITE";
-    case AccessMode::WRITE_ONLY:
-        return "AccessMode::WRITE_ONLY";
+    case AccessMode::ReadOnly:
+        return "AccessMode::ReadOnly";
+    case AccessMode::ReadWrite:
+        return "AccessMode::ReadWrite";
+    case AccessMode::WriteOnly:
+        return "AccessMode::WriteOnly";
     }
 
-    return "AccessMode::UNDEFINED_VALUE";
+    return "AccessMode::UndefinedValue";
 }
 
 

iceoryx_hoofs/filesystem/include/iox/filesystem.hpp

@@ -42,8 +42,8 @@ constexpr char ASCII_UNDERSCORE{'_'};
 
 enum class RelativePathComponents : uint8_t
 {
-    REJECT,
-    ACCEPT
+    Reject,
+    Accept
 };
 
 /// @brief checks if the given string is a valid path entry. A path entry is the string between
@@ -93,22 +93,22 @@ bool doesEndWithPathSeparator(const string<StringCapacity>& name) noexcept;
 
 enum class AccessMode : uint8_t
 {
-    READ_ONLY = 0U,
-    READ_WRITE = 1U,
-    WRITE_ONLY = 2U
+    ReadOnly = 0U,
+    ReadWrite = 1U,
+    WriteOnly = 2U
 };
 
 /// @brief describes how the shared memory is opened or created
 enum class OpenMode : uint8_t
 {
     /// @brief creates the shared memory, if it exists already the construction will fail
-    EXCLUSIVE_CREATE = 0U,
+    ExclusiveCreate = 0U,
     /// @brief creates the shared memory, if it exists it will be deleted and recreated
-    PURGE_AND_CREATE = 1U,
+    PurgeAndCreate = 1U,
     /// @brief creates the shared memory, if it does not exist otherwise it opens it
-    OPEN_OR_CREATE = 2U,
+    OpenOrCreate = 2U,
     /// @brief opens the shared memory, if it does not exist it will fail
-    OPEN_EXISTING = 3U
+    OpenExisting = 3U
 };
 
 /// @brief converts OpenMode into a string literal

iceoryx_hoofs/filesystem/source/filesystem.cpp

@@ -180,11 +180,11 @@ int convertToOflags(const AccessMode accessMode) noexcept
 {
     switch (accessMode)
     {
-    case AccessMode::READ_ONLY:
+    case AccessMode::ReadOnly:
         return O_RDONLY;
-    case AccessMode::READ_WRITE:
+    case AccessMode::ReadWrite:
         return O_RDWR;
-    case AccessMode::WRITE_ONLY:
+    case AccessMode::WriteOnly:
         return O_WRONLY;
     }
 
@@ -196,12 +196,12 @@ int convertToOflags(const OpenMode openMode) noexcept
 {
     switch (openMode)
     {
-    case OpenMode::OPEN_EXISTING:
+    case OpenMode::OpenExisting:
         return 0;
-    case OpenMode::OPEN_OR_CREATE:
+    case OpenMode::OpenOrCreate:
         return O_CREAT;
-    case OpenMode::EXCLUSIVE_CREATE:
-    case OpenMode::PURGE_AND_CREATE:
+    case OpenMode::ExclusiveCreate:
+    case OpenMode::PurgeAndCreate:
         // wrapped inside function so that the user does not have to use bitwise operations; operands have positive
         // values and result is within integer range
         // NOLINTNEXTLINE(hicpp-signed-bitwise)
@@ -216,12 +216,12 @@ int convertToProtFlags(const AccessMode accessMode) noexcept
 {
     switch (accessMode)
     {
-    case AccessMode::READ_ONLY:
+    case AccessMode::ReadOnly:
         return PROT_READ;
-    case AccessMode::READ_WRITE:
+    case AccessMode::ReadWrite:
         // NOLINTNEXTLINE(hicpp-signed-bitwise) enum type is defined by POSIX, no logical fault
         return PROT_READ | PROT_WRITE;
-    case AccessMode::WRITE_ONLY:
+    case AccessMode::WriteOnly:
         return PROT_WRITE;
     }
 

iceoryx_hoofs/posix/filesystem/include/iox/file.hpp

@@ -169,16 +169,16 @@ class File : public FileManagementInterface<File>
     static constexpr int INVALID_FILE_DESCRIPTOR{-1};
 
     int m_file_descriptor{INVALID_FILE_DESCRIPTOR};
-    AccessMode m_access_mode{AccessMode::READ_ONLY};
+    AccessMode m_access_mode{AccessMode::ReadOnly};
 };
 
 class FileBuilder
 {
   private:
     IOX_BUILDER_PARAMETER(Ownership, owner, Ownership::from_process())
     IOX_BUILDER_PARAMETER(access_rights, permissions, perms::owner_read)
-    IOX_BUILDER_PARAMETER(AccessMode, access_mode, AccessMode::READ_ONLY)
-    IOX_BUILDER_PARAMETER(OpenMode, open_mode, OpenMode::OPEN_EXISTING)
+    IOX_BUILDER_PARAMETER(AccessMode, access_mode, AccessMode::ReadOnly)
+    IOX_BUILDER_PARAMETER(OpenMode, open_mode, OpenMode::OpenExisting)
 
   public:
     expected<File, FileCreationError> create(const FilePath& name) noexcept;

iceoryx_hoofs/posix/filesystem/source/file.cpp

@@ -26,7 +26,7 @@ namespace iox
 {
 expected<File, FileCreationError> FileBuilder::create(const FilePath& name) noexcept
 {
-    if (m_open_mode == OpenMode::PURGE_AND_CREATE)
+    if (m_open_mode == OpenMode::PurgeAndCreate)
     {
         if (File::remove(name).has_error())
         {
@@ -59,7 +59,7 @@ expected<File, FileCreationError> FileBuilder::open(const FilePath& name) noexce
             return err(FileCreationError::PermissionDenied);
         }
 
-        if (m_access_mode == AccessMode::READ_ONLY || m_access_mode == AccessMode::READ_WRITE)
+        if (m_access_mode == AccessMode::ReadOnly || m_access_mode == AccessMode::ReadWrite)
         {
             if ((perms->value() & perms::owner_read.value()) == 0)
             {
@@ -69,7 +69,7 @@ expected<File, FileCreationError> FileBuilder::open(const FilePath& name) noexce
             }
         }
 
-        if (m_access_mode == AccessMode::WRITE_ONLY || m_access_mode == AccessMode::READ_WRITE)
+        if (m_access_mode == AccessMode::WriteOnly || m_access_mode == AccessMode::ReadWrite)
         {
             if ((perms->value() & perms::owner_write.value()) == 0)
             {
@@ -328,7 +328,7 @@ expected<uint64_t, FileReadError> File::read(uint8_t* const buffer, const uint64
 expected<uint64_t, FileReadError>
 File::read_at(const uint64_t offset, uint8_t* const buffer, const uint64_t buffer_len) const noexcept
 {
-    if (m_access_mode == AccessMode::WRITE_ONLY)
+    if (m_access_mode == AccessMode::WriteOnly)
     {
         IOX_LOG(Error, "Unable to read from file since it is opened for writing only.");
         return err(FileReadError::NotOpenedForReading);
@@ -384,7 +384,7 @@ expected<uint64_t, FileWriteError> File::write(const uint8_t* const buffer, cons
 expected<uint64_t, FileWriteError>
 File::write_at(const uint64_t offset, const uint8_t* const buffer, const uint64_t buffer_len) const noexcept
 {
-    if (m_access_mode == AccessMode::READ_ONLY)
+    if (m_access_mode == AccessMode::ReadOnly)
     {
         IOX_LOG(Error, "Unable to write to file since it is opened for reading only.");
         return err(FileWriteError::NotOpenedForWriting);

iceoryx_hoofs/posix/filesystem/source/file_lock.cpp

@@ -56,7 +56,7 @@ expected<FileLock, FileLockError> FileLockBuilder::create() noexcept
     fileLockPath.unsafe_append(FileLock::LOCK_FILE_SUFFIX);
 
     auto openCall = IOX_POSIX_CALL(iox_ext_open)(fileLockPath.c_str(),
-                                                 convertToOflags(AccessMode::READ_ONLY, OpenMode::OPEN_OR_CREATE),
+                                                 convertToOflags(AccessMode::ReadOnly, OpenMode::OpenOrCreate),
                                                  m_permission.value())
                         .failureReturnValue(-1)
                         .evaluate();

iceoryx_hoofs/posix/ipc/include/iox/detail/posix_memory_map.hpp

@@ -83,7 +83,7 @@ class PosixMemoryMapBuilder
 
     /// @brief Defines if the memory should be mapped read only or with write access.
     ///        A read only memory section will cause a segmentation fault when written to.
-    IOX_BUILDER_PARAMETER(AccessMode, accessMode, AccessMode::READ_WRITE)
+    IOX_BUILDER_PARAMETER(AccessMode, accessMode, AccessMode::ReadWrite)
 
     /// @brief Sets the flags defining how the mapped data should be handled
     IOX_BUILDER_PARAMETER(PosixMemoryMapFlags, flags, PosixMemoryMapFlags::SHARE_CHANGES)

iceoryx_hoofs/posix/ipc/include/iox/detail/posix_shared_memory.hpp

@@ -76,7 +76,7 @@ class PosixSharedMemory : public FileManagementInterface<PosixSharedMemory>
 
     /// @brief this class has the ownership of the shared memory when the shared
     ///        memory was created by this class. This is the case when this class
-    ///        was successful created with EXCLUSIVE_CREATE, PURGE_AND_CREATE or OPEN_OR_CREATE
+    ///        was successful created with ExclusiveCreate, PurgeAndCreate or OpenOrCreate
     ///        and the shared memory was created. If an already available shared memory
     ///        is opened then this class does not have the ownership.
     bool hasOwnership() const noexcept;
@@ -116,10 +116,10 @@ class PosixSharedMemoryBuilder
 
     /// @brief Defines if the memory should be mapped read only or with write access.
     ///        A read only memory section will cause a segmentation fault when written to.
-    IOX_BUILDER_PARAMETER(AccessMode, accessMode, AccessMode::READ_ONLY)
+    IOX_BUILDER_PARAMETER(AccessMode, accessMode, AccessMode::ReadOnly)
 
     /// @brief Defines how the shared memory is acquired
-    IOX_BUILDER_PARAMETER(OpenMode, openMode, OpenMode::OPEN_EXISTING)
+    IOX_BUILDER_PARAMETER(OpenMode, openMode, OpenMode::OpenExisting)
 
     /// @brief Defines the access permissions of the shared memory
     IOX_BUILDER_PARAMETER(access_rights, filePermissions, perms::none)