iox-eclipse-iceoryx#2301 Squash me

iceoryx_hoofs/CMakeLists.txt

@@ -136,7 +136,7 @@ iox_add_library(
         posix/sync/source/named_semaphore.cpp
         posix/sync/source/signal_handler.cpp
         posix/sync/source/signal_watcher.cpp
-        posix/sync/source/semaphore_interface.cpp
+        posix/sync/source/semaphore_helper.cpp
         posix/sync/source/thread.cpp
         posix/sync/source/unnamed_semaphore.cpp
         posix/time/source/adaptive_wait.cpp

iceoryx_hoofs/concurrent/sync/include/iox/spin_semaphore.hpp

@@ -21,8 +21,9 @@
 #include "iox/atomic.hpp"
 #include "iox/deadline_timer.hpp"
 #include "iox/detail/adaptive_wait.hpp"
-#include "iox/detail/semaphore_interface.hpp"
+#include "iox/detail/semaphore_helper.hpp"
 #include "iox/optional.hpp"
+#include "iox/semaphore_interface.hpp"
 #include "iox/spin_lock.hpp"
 
 namespace iox
@@ -43,18 +44,19 @@ class SpinSemaphore : public detail::SemaphoreInterface<SpinSemaphore>
 
     ~SpinSemaphore() noexcept;
 
-    expected<void, SemaphoreError> post() noexcept;
+  private:
+    friend class optional<SpinSemaphore>;
+    friend class detail::SemaphoreInterface<SpinSemaphore>;
 
-    expected<void, SemaphoreError> wait() noexcept;
+    explicit SpinSemaphore(int32_t initial_value) noexcept;
 
-    expected<bool, SemaphoreError> tryWait() noexcept;
+    expected<void, SemaphoreError> post_impl() noexcept;
 
-    expected<SemaphoreWaitState, SemaphoreError> timedWait(const units::Duration& timeout) noexcept;
+    expected<void, SemaphoreError> wait_impl() noexcept;
 
-  private:
-    friend class optional<SpinSemaphore>;
+    expected<bool, SemaphoreError> try_wait_impl() noexcept;
 
-    explicit SpinSemaphore(int32_t initial_value) noexcept;
+    expected<SemaphoreWaitState, SemaphoreError> timed_wait_impl(const units::Duration& timeout) noexcept;
 
   private:
     concurrent::Atomic<int32_t> m_count{0};

iceoryx_hoofs/concurrent/sync/source/spin_semaphore.cpp

@@ -43,21 +43,21 @@ SpinSemaphore::~SpinSemaphore() noexcept
     m_to_be_destroyed = true;
 }
 
-expected<void, SemaphoreError> SpinSemaphore::post() noexcept
+expected<void, SemaphoreError> SpinSemaphore::post_impl() noexcept
 {
     std::lock_guard<concurrent::SpinLock> lock(*m_spinlock);
     ++m_count;
     return ok();
 }
 
-expected<void, SemaphoreError> SpinSemaphore::wait() noexcept
+expected<void, SemaphoreError> SpinSemaphore::wait_impl() noexcept
 {
     detail::adaptive_wait spinner;
     spinner.wait_loop([this] { return !this->tryWait(); });
     return ok();
 }
 
-expected<bool, SemaphoreError> SpinSemaphore::tryWait() noexcept
+expected<bool, SemaphoreError> SpinSemaphore::try_wait_impl() noexcept
 {
     std::lock_guard<concurrent::SpinLock> lock(*m_spinlock);
     if (m_to_be_destroyed.load(std::memory_order_relaxed))
@@ -72,7 +72,7 @@ expected<bool, SemaphoreError> SpinSemaphore::tryWait() noexcept
     return ok(false);
 }
 
-expected<SemaphoreWaitState, SemaphoreError> SpinSemaphore::timedWait(const units::Duration& timeout) noexcept
+expected<SemaphoreWaitState, SemaphoreError> SpinSemaphore::timed_wait_impl(const units::Duration& timeout) noexcept
 {
     iox::deadline_timer deadline_timer(timeout);
     detail::adaptive_wait spinner;

iceoryx_hoofs/posix/sync/include/iox/detail/semaphore_interface.hpp → iceoryx_hoofs/design/include/iox/semaphore_interface.hpp

@@ -1,4 +1,5 @@
 // Copyright (c) 2022 by Apex.AI Inc. All rights reserved.
+// Copyright (c) 2024 by ekxide IO GmbH. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -14,8 +15,8 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-#ifndef IOX_HOOFS_POSIX_SYNC_SEMAPHORE_INTERFACE_HPP
-#define IOX_HOOFS_POSIX_SYNC_SEMAPHORE_INTERFACE_HPP
+#ifndef IOX_HOOFS_DESIGN_SEMAPHORE_INTERFACE_HPP
+#define IOX_HOOFS_DESIGN_SEMAPHORE_INTERFACE_HPP
 
 #include "iceoryx_platform/semaphore.hpp"
 #include "iox/duration.hpp"
@@ -59,32 +60,41 @@ class SemaphoreInterface
     /// @brief Increments the semaphore by one
     /// @return Fails when the value of the semaphore overflows or when the
     ///         semaphore was removed from outside the process
-    expected<void, SemaphoreError> post() noexcept;
+    expected<void, SemaphoreError> post() noexcept
+    {
+        return static_cast<SemaphoreChild*>(this)->post_impl();
+    }
 
     /// @brief Decrements the semaphore by one. When the semaphore value is zero
     ///        it blocks until the semaphore value is greater zero
     /// @return Fails when semaphore was removed from outside the process
-    expected<void, SemaphoreError> wait() noexcept;
+    expected<void, SemaphoreError> wait() noexcept
+    {
+        return static_cast<SemaphoreChild*>(this)->wait_impl();
+    }
 
     /// @brief Tries to decrement the semaphore by one. When the semaphore value is zero
     ///        it returns false otherwise it returns true and decrement the value by one.
     /// @return Fails when semaphore was removed from outside the process
-    expected<bool, SemaphoreError> tryWait() noexcept;
+    expected<bool, SemaphoreError> tryWait() noexcept
+    {
+        return static_cast<SemaphoreChild*>(this)->try_wait_impl();
+    }
 
     /// @brief Tries to decrement the semaphore by one. When the semaphore value is zero
     ///        it waits until the timeout has passed.
     /// @return If during the timeout time the semaphore value increases to non zero
     ///         it returns SemaphoreWaitState::NO_TIMEOUT and decreases the semaphore by one
     ///         otherwise returns SemaphoreWaitState::TIMEOUT
-    expected<SemaphoreWaitState, SemaphoreError> timedWait(const units::Duration& timeout) noexcept;
+    expected<SemaphoreWaitState, SemaphoreError> timedWait(const units::Duration& timeout) noexcept
+    {
+        return static_cast<SemaphoreChild*>(this)->timed_wait_impl(timeout);
+    }
 
   protected:
     SemaphoreInterface() noexcept = default;
-
-  private:
-    iox_sem_t* getHandle() noexcept;
 };
 } // namespace detail
 } // namespace iox
 
-#endif // IOX_HOOFS_POSIX_SYNC_SEMAPHORE_INTERFACE_HPP
+#endif // IOX_HOOFS_DESIGN_SEMAPHORE_INTERFACE_HPP

iceoryx_hoofs/posix/sync/include/iox/detail/semaphore_helper.hpp

@@ -0,0 +1,54 @@
+// Copyright (c) 2022 by Apex.AI Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef IOX_HOOFS_POSIX_SYNC_SEMAPHORE_HELPER_HPP
+#define IOX_HOOFS_POSIX_SYNC_SEMAPHORE_HELPER_HPP
+
+#include "iceoryx_platform/semaphore.hpp"
+#include "iox/duration.hpp"
+#include "iox/expected.hpp"
+#include "iox/semaphore_interface.hpp"
+
+namespace iox
+{
+namespace detail
+{
+/// @brief Increments the semaphore by one
+/// @return Fails when the value of the semaphore overflows or when the
+///         semaphore was removed from outside the process
+expected<void, SemaphoreError> sem_post(iox_sem_t* handle) noexcept;
+
+/// @brief Decrements the semaphore by one. When the semaphore value is zero
+///        it blocks until the semaphore value is greater zero
+/// @return Fails when semaphore was removed from outside the process
+expected<void, SemaphoreError> sem_wait(iox_sem_t* handle) noexcept;
+
+/// @brief Tries to decrement the semaphore by one. When the semaphore value is zero
+///        it returns false otherwise it returns true and decrement the value by one.
+/// @return Fails when semaphore was removed from outside the process
+expected<bool, SemaphoreError> sem_try_wait(iox_sem_t* handle) noexcept;
+
+/// @brief Tries to decrement the semaphore by one. When the semaphore value is zero
+///        it waits until the timeout has passed.
+/// @return If during the timeout time the semaphore value increases to non zero
+///         it returns SemaphoreWaitState::NO_TIMEOUT and decreases the semaphore by one
+///         otherwise returns SemaphoreWaitState::TIMEOUT
+expected<SemaphoreWaitState, SemaphoreError> sem_timed_wait(iox_sem_t* handle, const units::Duration& timeout) noexcept;
+
+} // namespace detail
+} // namespace iox
+
+#endif // IOX_HOOFS_POSIX_SYNC_SEMAPHORE_HELPER_HPP

iceoryx_hoofs/posix/sync/include/iox/named_semaphore.hpp

@@ -19,10 +19,11 @@
 
 #include "iceoryx_platform/platform_settings.hpp"
 #include "iox/builder.hpp"
-#include "iox/detail/semaphore_interface.hpp"
+#include "iox/detail/semaphore_helper.hpp"
 #include "iox/expected.hpp"
 #include "iox/filesystem.hpp"
 #include "iox/optional.hpp"
+#include "iox/semaphore_interface.hpp"
 #include "iox/string.hpp"
 
 namespace iox
@@ -50,7 +51,11 @@ class NamedSemaphore final : public detail::SemaphoreInterface<NamedSemaphore>
     friend class detail::SemaphoreInterface<NamedSemaphore>;
 
     NamedSemaphore(iox_sem_t* handle, const Name_t& name, const bool hasOwnership) noexcept;
-    iox_sem_t* getHandle() noexcept;
+
+    expected<void, SemaphoreError> post_impl() noexcept;
+    expected<void, SemaphoreError> wait_impl() noexcept;
+    expected<bool, SemaphoreError> try_wait_impl() noexcept;
+    expected<SemaphoreWaitState, SemaphoreError> timed_wait_impl(const units::Duration& timeout) noexcept;
 
     iox_sem_t* m_handle = nullptr;
     Name_t m_name;

iceoryx_hoofs/posix/sync/include/iox/unnamed_semaphore.hpp

@@ -18,9 +18,10 @@
 #define IOX_HOOFS_POSIX_SYNC_UNNAMED_SEMAPHORE_HPP
 
 #include "iox/builder.hpp"
-#include "iox/detail/semaphore_interface.hpp"
+#include "iox/detail/semaphore_helper.hpp"
 #include "iox/expected.hpp"
 #include "iox/optional.hpp"
+#include "iox/semaphore_interface.hpp"
 
 namespace iox
 {
@@ -48,7 +49,11 @@ class UnnamedSemaphore final : public detail::SemaphoreInterface<UnnamedSemaphor
     friend class detail::SemaphoreInterface<UnnamedSemaphore>;
 
     UnnamedSemaphore() noexcept = default;
-    iox_sem_t* getHandle() noexcept;
+
+    expected<void, SemaphoreError> post_impl() noexcept;
+    expected<void, SemaphoreError> wait_impl() noexcept;
+    expected<bool, SemaphoreError> try_wait_impl() noexcept;
+    expected<SemaphoreWaitState, SemaphoreError> timed_wait_impl(const units::Duration& timeout) noexcept;
 
     iox_sem_t m_handle;
     bool m_destroyHandle = true;

iceoryx_hoofs/posix/sync/source/named_semaphore.cpp

@@ -239,8 +239,20 @@ NamedSemaphore::~NamedSemaphore() noexcept
     }
 }
 
-iox_sem_t* NamedSemaphore::getHandle() noexcept
+expected<void, SemaphoreError> NamedSemaphore::post_impl() noexcept
 {
-    return m_handle;
+    return detail::sem_post(m_handle);
+}
+expected<void, SemaphoreError> NamedSemaphore::wait_impl() noexcept
+{
+    return detail::sem_wait(m_handle);
+}
+expected<bool, SemaphoreError> NamedSemaphore::try_wait_impl() noexcept
+{
+    return detail::sem_try_wait(m_handle);
+}
+expected<SemaphoreWaitState, SemaphoreError> NamedSemaphore::timed_wait_impl(const units::Duration& timeout) noexcept
+{
+    return detail::sem_timed_wait(m_handle, timeout);
 }
 } // namespace iox

iceoryx_hoofs/posix/sync/source/semaphore_interface.cpp → iceoryx_hoofs/posix/sync/source/semaphore_helper.cpp

@@ -14,17 +14,15 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-#include "iox/detail/semaphore_interface.hpp"
+#include "iox/detail/semaphore_helper.hpp"
 #include "iox/logging.hpp"
-#include "iox/named_semaphore.hpp"
 #include "iox/posix_call.hpp"
-#include "iox/unnamed_semaphore.hpp"
 
 namespace iox
 {
 namespace detail
 {
-SemaphoreError errnoToEnum(const int32_t errnum) noexcept
+SemaphoreError sem_errno_to_enum(const int32_t errnum) noexcept
 {
     switch (errnum)
     {
@@ -44,70 +42,57 @@ SemaphoreError errnoToEnum(const int32_t errnum) noexcept
     return SemaphoreError::UNDEFINED;
 }
 
-template <typename SemaphoreChild>
-iox_sem_t* SemaphoreInterface<SemaphoreChild>::getHandle() noexcept
+expected<void, SemaphoreError> sem_post(iox_sem_t* handle) noexcept
 {
-    return static_cast<SemaphoreChild*>(this)->getHandle();
-}
-
-template <typename SemaphoreChild>
-expected<void, SemaphoreError> SemaphoreInterface<SemaphoreChild>::post() noexcept
-{
-    auto result = IOX_POSIX_CALL(iox_sem_post)(getHandle()).failureReturnValue(-1).evaluate();
+    auto result = IOX_POSIX_CALL(iox_sem_post)(handle).failureReturnValue(-1).evaluate();
 
     if (result.has_error())
     {
-        return err(errnoToEnum(result.error().errnum));
+        return err(sem_errno_to_enum(result.error().errnum));
     }
 
     return ok<void>();
 }
 
-template <typename SemaphoreChild>
-expected<SemaphoreWaitState, SemaphoreError>
-SemaphoreInterface<SemaphoreChild>::timedWait(const units::Duration& timeout) noexcept
+expected<SemaphoreWaitState, SemaphoreError> sem_timed_wait(iox_sem_t* handle, const units::Duration& timeout) noexcept
 {
     const timespec timeoutAsTimespec = timeout.timespec(units::TimeSpecReference::Epoch);
-    auto result = IOX_POSIX_CALL(iox_sem_timedwait)(getHandle(), &timeoutAsTimespec)
+    auto result = IOX_POSIX_CALL(iox_sem_timedwait)(handle, &timeoutAsTimespec)
                       .failureReturnValue(-1)
                       .ignoreErrnos(ETIMEDOUT)
                       .evaluate();
 
     if (result.has_error())
     {
-        return err(errnoToEnum(result.error().errnum));
+        return err(sem_errno_to_enum(result.error().errnum));
     }
 
     return ok((result.value().errnum == ETIMEDOUT) ? SemaphoreWaitState::TIMEOUT : SemaphoreWaitState::NO_TIMEOUT);
 }
 
-template <typename SemaphoreChild>
-expected<bool, SemaphoreError> SemaphoreInterface<SemaphoreChild>::tryWait() noexcept
+expected<bool, SemaphoreError> sem_try_wait(iox_sem_t* handle) noexcept
 {
-    auto result = IOX_POSIX_CALL(iox_sem_trywait)(getHandle()).failureReturnValue(-1).ignoreErrnos(EAGAIN).evaluate();
+    auto result = IOX_POSIX_CALL(iox_sem_trywait)(handle).failureReturnValue(-1).ignoreErrnos(EAGAIN).evaluate();
 
     if (result.has_error())
     {
-        return err(errnoToEnum(result.error().errnum));
+        return err(sem_errno_to_enum(result.error().errnum));
     }
 
     return ok(result.value().errnum != EAGAIN);
 }
 
-template <typename SemaphoreChild>
-expected<void, SemaphoreError> SemaphoreInterface<SemaphoreChild>::wait() noexcept
+expected<void, SemaphoreError> sem_wait(iox_sem_t* handle) noexcept
 {
-    auto result = IOX_POSIX_CALL(iox_sem_wait)(getHandle()).failureReturnValue(-1).evaluate();
+    auto result = IOX_POSIX_CALL(iox_sem_wait)(handle).failureReturnValue(-1).evaluate();
 
     if (result.has_error())
     {
-        return err(errnoToEnum(result.error().errnum));
+        return err(sem_errno_to_enum(result.error().errnum));
     }
 
     return ok<void>();
 }
 
-template class SemaphoreInterface<UnnamedSemaphore>;
-template class SemaphoreInterface<NamedSemaphore>;
 } // namespace detail
 } // namespace iox