iox-#27 Use ConsumerTooSlowPolicy instead of SubscriberTooSlowPolicy

iceoryx_binding_c/include/iceoryx_binding_c/enums.h

@@ -50,7 +50,8 @@ enum iox_ChunkReceiveResult
     ChunkReceiveResult_SUCCESS,
 };
 
-/// @brief used by subscriber; describes whether a publisher blocks when subscriber queue is full
+/// @brief Used by consumers to request a specific behavior from the producer; describes whether a producer blocks when
+/// consumer queue is full
 enum iox_QueueFullPolicy
 {
     QueueFullPolicy_BLOCK_PRODUCER,
@@ -60,12 +61,18 @@ enum iox_QueueFullPolicy
     QueueFullPolicy_DISCARD_OLDEST_DATA,
 };
 
-/// @brief used by publisher; describes whether a publisher blocks when subscriber queue is full
-enum iox_SubscriberTooSlowPolicy
+/// @brief Used by producers how to adjust to slow consumer; describes whether a producer blocks when consumer queue is
+/// full
+enum iox_ConsumerTooSlowPolicy
 {
-    SubscriberTooSlowPolicy_WAIT_FOR_SUBSCRIBER,
-    SubscriberTooSlowPolicy_DISCARD_OLDEST_DATA,
+    ConsumerTooSlowPolicy_WAIT_FOR_CONSUMER,
+    ConsumerTooSlowPolicy_DISCARD_OLDEST_DATA,
 };
+/// @deprecated Compatibility alias for the legacy use with publisher only. Will be remove in a future release.
+/// Please use `iox_ConsumerTooSlowPolicy` instead.
+typedef enum iox_ConsumerTooSlowPolicy iox_SubscriberTooSlowPolicy;
+#define SubscriberTooSlowPolicy_WAIT_FOR_SUBSCRIBER ConsumerTooSlowPolicy_WAIT_FOR_CONSUMER
+#define SubscriberTooSlowPolicy_DISCARD_OLDEST_DATA ConsumerTooSlowPolicy_DISCARD_OLDEST_DATA
 
 /// @brief state of allocateChunk
 enum iox_AllocationResult

iceoryx_binding_c/include/iceoryx_binding_c/internal/c2cpp_enum_translation.hpp

@@ -24,7 +24,8 @@
 
 namespace c2cpp
 {
-iox::popo::SubscriberTooSlowPolicy subscriberTooSlowPolicy(const ENUM iox_SubscriberTooSlowPolicy policy) noexcept;
+iox::popo::ConsumerTooSlowPolicy consumerTooSlowPolicy(const ENUM iox_ConsumerTooSlowPolicy policy) noexcept;
+iox::popo::ConsumerTooSlowPolicy subscriberTooSlowPolicy(const ENUM iox_SubscriberTooSlowPolicy policy) noexcept;
 iox::popo::QueueFullPolicy queueFullPolicy(const ENUM iox_QueueFullPolicy policy) noexcept;
 iox::popo::SubscriberEvent subscriberEvent(const iox_SubscriberEvent value) noexcept;
 iox::popo::SubscriberState subscriberState(const iox_SubscriberState value) noexcept;

iceoryx_binding_c/include/iceoryx_binding_c/internal/cpp2c_enum_translation.hpp

@@ -33,7 +33,8 @@ iox_ChunkReceiveResult chunkReceiveResult(const iox::popo::ChunkReceiveResult va
 iox_AllocationResult allocationResult(const iox::popo::AllocationError value) noexcept;
 iox_WaitSetResult waitSetResult(const iox::popo::WaitSetError value) noexcept;
 iox_ListenerResult listenerResult(const iox::popo::ListenerError value) noexcept;
-iox_SubscriberTooSlowPolicy subscriberTooSlowPolicy(const iox::popo::SubscriberTooSlowPolicy policy) noexcept;
+iox_ConsumerTooSlowPolicy consumerTooSlowPolicy(const iox::popo::ConsumerTooSlowPolicy policy) noexcept;
+iox_ConsumerTooSlowPolicy subscriberTooSlowPolicy(const iox::popo::ConsumerTooSlowPolicy policy) noexcept;
 iox_QueueFullPolicy queueFullPolicy(const iox::popo::QueueFullPolicy policy) noexcept;
 } // namespace cpp2c
 

iceoryx_binding_c/include/iceoryx_binding_c/publisher.h

@@ -40,7 +40,7 @@ typedef struct
     bool offerOnCreate;
 
     /// @brief describes whether a publisher blocks when subscriber queue is full
-    ENUM iox_SubscriberTooSlowPolicy subscriberTooSlowPolicy;
+    ENUM iox_ConsumerTooSlowPolicy subscriberTooSlowPolicy;
 
     /// @brief this value will be set exclusively by `iox_pub_options_init` and is not supposed to be modified otherwise
     uint64_t initCheck;

iceoryx_binding_c/include/iceoryx_binding_c/runtime.h

@@ -34,7 +34,7 @@ void iox_runtime_init(const char* const name);
 uint64_t iox_runtime_get_instance_name(char* const name, const uint64_t nameLength);
 
 /// @brief initiates the shutdown of the runtime to unblock all potentially blocking publisher
-/// with the iox_SubscriberTooSlowPolicy::SubscriberTooSlowPolicy_WAIT_FOR_SUBSCRIBER option set
+/// with the iox_ConsumerTooSlowPolicy::ConsumerTooSlowPolicy_WAIT_FOR_CONSUMER option set
 void iox_runtime_shutdown();
 
 #endif

iceoryx_binding_c/source/c2cpp_enum_translation.cpp

@@ -20,19 +20,23 @@
 
 namespace c2cpp
 {
-iox::popo::SubscriberTooSlowPolicy subscriberTooSlowPolicy(const ENUM iox_SubscriberTooSlowPolicy policy) noexcept
+iox::popo::ConsumerTooSlowPolicy consumerTooSlowPolicy(const ENUM iox_ConsumerTooSlowPolicy policy) noexcept
 {
     switch (policy)
     {
-    case SubscriberTooSlowPolicy_WAIT_FOR_SUBSCRIBER:
-        return iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER;
-    case SubscriberTooSlowPolicy_DISCARD_OLDEST_DATA:
-        return iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA;
+    case ConsumerTooSlowPolicy_WAIT_FOR_CONSUMER:
+        return iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER;
+    case ConsumerTooSlowPolicy_DISCARD_OLDEST_DATA:
+        return iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA;
     }
 
     errorHandler(
-        iox::Error::kBINDING_C__UNDEFINED_STATE_IN_IOX_SUBSCRIBER_TOO_SLOW_POLICY, nullptr, iox::ErrorLevel::MODERATE);
-    return iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA;
+        iox::Error::kBINDING_C__UNDEFINED_STATE_IN_IOX_CONSUMER_TOO_SLOW_POLICY, nullptr, iox::ErrorLevel::MODERATE);
+    return iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA;
+}
+iox::popo::ConsumerTooSlowPolicy subscriberTooSlowPolicy(const ENUM iox_SubscriberTooSlowPolicy policy) noexcept
+{
+    return consumerTooSlowPolicy(policy);
 }
 
 iox::popo::QueueFullPolicy queueFullPolicy(const ENUM iox_QueueFullPolicy policy) noexcept

iceoryx_binding_c/source/c_publisher.cpp

@@ -47,7 +47,7 @@ void iox_pub_options_init(iox_pub_options_t* options)
     options->historyCapacity = publisherOptions.historyCapacity;
     options->nodeName = nullptr;
     options->offerOnCreate = publisherOptions.offerOnCreate;
-    options->subscriberTooSlowPolicy = cpp2c::subscriberTooSlowPolicy(publisherOptions.subscriberTooSlowPolicy);
+    options->subscriberTooSlowPolicy = cpp2c::consumerTooSlowPolicy(publisherOptions.subscriberTooSlowPolicy);
 
     options->initCheck = PUBLISHER_OPTIONS_INIT_CHECK_CONSTANT;
 }
@@ -90,7 +90,7 @@ iox_pub_t iox_pub_init(iox_pub_storage_t* self,
             publisherOptions.nodeName = NodeName_t(TruncateToCapacity, options->nodeName);
         }
         publisherOptions.offerOnCreate = options->offerOnCreate;
-        publisherOptions.subscriberTooSlowPolicy = c2cpp::subscriberTooSlowPolicy(options->subscriberTooSlowPolicy);
+        publisherOptions.subscriberTooSlowPolicy = c2cpp::consumerTooSlowPolicy(options->subscriberTooSlowPolicy);
     }
 
     me->m_portData = PoshRuntime::getInstance().getMiddlewarePublisher(

iceoryx_binding_c/source/cpp2c_enum_translation.cpp

@@ -101,16 +101,20 @@ iox_ListenerResult listenerResult(const iox::popo::ListenerError value) noexcept
     return ListenerResult_UNDEFINED_ERROR;
 }
 
-iox_SubscriberTooSlowPolicy subscriberTooSlowPolicy(const iox::popo::SubscriberTooSlowPolicy policy) noexcept
+iox_ConsumerTooSlowPolicy consumerTooSlowPolicy(const iox::popo::ConsumerTooSlowPolicy policy) noexcept
 {
     switch (policy)
     {
-    case SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER:
-        return SubscriberTooSlowPolicy_WAIT_FOR_SUBSCRIBER;
-    case SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA:
-        return SubscriberTooSlowPolicy_DISCARD_OLDEST_DATA;
+    case ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER:
+        return ConsumerTooSlowPolicy_WAIT_FOR_CONSUMER;
+    case ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA:
+        return ConsumerTooSlowPolicy_DISCARD_OLDEST_DATA;
     }
-    return SubscriberTooSlowPolicy_DISCARD_OLDEST_DATA;
+    return ConsumerTooSlowPolicy_DISCARD_OLDEST_DATA;
+}
+iox_ConsumerTooSlowPolicy subscriberTooSlowPolicy(const iox::popo::ConsumerTooSlowPolicy policy) noexcept
+{
+    return consumerTooSlowPolicy(policy);
 }
 iox_QueueFullPolicy queueFullPolicy(const iox::popo::QueueFullPolicy policy) noexcept
 {

iceoryx_binding_c/test/moduletests/test_c2cpp_enum_translation.cpp

@@ -97,9 +97,9 @@ TEST(c2cpp_enum_translation_test, SubscriberEvent)
     iox::Error errorValue = iox::Error::kNO_ERROR;
     auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
         [&](const iox::Error e, const std::function<void()>, const iox::ErrorLevel) { errorValue = e; });
-    EXPECT_EQ(c2cpp::subscriberTooSlowPolicy(static_cast<iox_SubscriberTooSlowPolicy>(-1)),
-              iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA);
-    EXPECT_THAT(errorValue, Eq(iox::Error::kBINDING_C__UNDEFINED_STATE_IN_IOX_SUBSCRIBER_TOO_SLOW_POLICY));
+    EXPECT_EQ(c2cpp::consumerTooSlowPolicy(static_cast<iox_ConsumerTooSlowPolicy>(-1)),
+              iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA);
+    EXPECT_THAT(errorValue, Eq(iox::Error::kBINDING_C__UNDEFINED_STATE_IN_IOX_CONSUMER_TOO_SLOW_POLICY));
 #endif
 #pragma GCC diagnostic pop
 }

iceoryx_binding_c/test/moduletests/test_cpp2c_enum_translation.cpp

@@ -217,18 +217,18 @@ TEST(cpp2c_enum_translation_test, ListenerResult)
 #pragma GCC diagnostic pop
 }
 
-TEST(cpp2c_enum_translation_test, SubscriberTooSlowPolicy)
+TEST(cpp2c_enum_translation_test, ConsumerTooSlowPolicy)
 {
     ::testing::Test::RecordProperty("TEST_ID", "aad706c2-5216-4835-b29f-8a89829d7238");
-    EXPECT_EQ(cpp2c::subscriberTooSlowPolicy(iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER),
-              SubscriberTooSlowPolicy_WAIT_FOR_SUBSCRIBER);
-    EXPECT_EQ(cpp2c::subscriberTooSlowPolicy(iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA),
-              SubscriberTooSlowPolicy_DISCARD_OLDEST_DATA);
+    EXPECT_EQ(cpp2c::consumerTooSlowPolicy(iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER),
+              ConsumerTooSlowPolicy_WAIT_FOR_CONSUMER);
+    EXPECT_EQ(cpp2c::consumerTooSlowPolicy(iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA),
+              ConsumerTooSlowPolicy_DISCARD_OLDEST_DATA);
     // ignore the warning since we would like to test the behavior of an invalid enum value
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wconversion"
-    EXPECT_EQ(cpp2c::subscriberTooSlowPolicy(static_cast<iox::popo::SubscriberTooSlowPolicy>(-1)),
-              SubscriberTooSlowPolicy_DISCARD_OLDEST_DATA);
+    EXPECT_EQ(cpp2c::consumerTooSlowPolicy(static_cast<iox::popo::ConsumerTooSlowPolicy>(-1)),
+              ConsumerTooSlowPolicy_DISCARD_OLDEST_DATA);
 #pragma GCC diagnostic pop
 }
 

iceoryx_binding_c/test/moduletests/test_publisher.cpp

@@ -352,7 +352,7 @@ TEST(iox_pub_options_test, publisherOptionsAreInitializedCorrectly)
     sut.historyCapacity = 37;
     sut.nodeName = "Dr.Gonzo";
     sut.offerOnCreate = false;
-    sut.subscriberTooSlowPolicy = SubscriberTooSlowPolicy_WAIT_FOR_SUBSCRIBER;
+    sut.subscriberTooSlowPolicy = ConsumerTooSlowPolicy_WAIT_FOR_CONSUMER;
 
     PublisherOptions options;
     // set offerOnCreate to the opposite of the expected default to check if it gets overwritten to default
@@ -362,7 +362,7 @@ TEST(iox_pub_options_test, publisherOptionsAreInitializedCorrectly)
     EXPECT_EQ(sut.historyCapacity, options.historyCapacity);
     EXPECT_EQ(sut.nodeName, nullptr);
     EXPECT_EQ(sut.offerOnCreate, options.offerOnCreate);
-    EXPECT_EQ(sut.subscriberTooSlowPolicy, cpp2c::subscriberTooSlowPolicy(options.subscriberTooSlowPolicy));
+    EXPECT_EQ(sut.subscriberTooSlowPolicy, cpp2c::consumerTooSlowPolicy(options.subscriberTooSlowPolicy));
     EXPECT_TRUE(iox_pub_options_is_initialized(&sut));
 }
 

iceoryx_examples/iceoptions/README.md

@@ -44,12 +44,12 @@ publisherOptions.nodeName = "Pub_Node_With_Options";
 ```
 
 To ensure that samples are never lost, you have the possibility to busy-wait for the subscriber when publishing.
-Both publisher and subscriber have to request compatible policies (`SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER` and
+Both publisher and subscriber have to request compatible policies (`ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER` and
 `QueueFullPolicy::BLOCK_PRODUCER`).
 
 <!--[geoffrey][iceoryx_examples/iceoptions/iox_publisher_with_options.cpp][too slow policy]-->
 ```cpp
-publisherOptions.subscriberTooSlowPolicy = iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER;
+publisherOptions.subscriberTooSlowPolicy = iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER;
 ```
 
 With this option set, it is possible that a slow subscriber blocks a publisher indefinitely due to the busy waiting loop.

iceoryx_examples/iceoptions/iox_publisher_with_options.cpp

@@ -48,7 +48,7 @@ int main()
 
     //  we allow the subscribers to block the publisher if they want to ensure that no samples are lost
     //! [too slow policy]
-    publisherOptions.subscriberTooSlowPolicy = iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER;
+    publisherOptions.subscriberTooSlowPolicy = iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER;
     //! [too slow policy]
 
     iox::popo::Publisher<RadarObject> publisher({"Radar", "FrontLeft", "Object"}, publisherOptions);
@@ -71,7 +71,7 @@ int main()
         std::this_thread::sleep_for(std::chrono::milliseconds(400));
     }
 
-    // this is optional, but since the iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER option is used,
+    // this is optional, but since the iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER option is used,
     // a slow subscriber might block the shutdown and this call unblocks the publisher
     //! [shutdown]
     iox::runtime::PoshRuntime::getInstance().shutdown();

iceoryx_hoofs/include/iceoryx_hoofs/error_handling/error_handling.hpp

@@ -161,7 +161,7 @@ namespace iox
     error(POSIX_TIMER__INCONSISTENT_STATE) \
     error(POSIX_TIMER__CALLBACK_RUNTIME_EXCEEDS_RETRIGGER_TIME) \
     error(BINDING_C__UNDEFINED_STATE_IN_IOX_QUEUE_FULL_POLICY) \
-    error(BINDING_C__UNDEFINED_STATE_IN_IOX_SUBSCRIBER_TOO_SLOW_POLICY) \
+    error(BINDING_C__UNDEFINED_STATE_IN_IOX_CONSUMER_TOO_SLOW_POLICY) \
     error(BINDING_C__PUBLISHER_OPTIONS_NOT_INITIALIZED) \
     error(BINDING_C__SUBSCRIBER_OPTIONS_NOT_INITIALIZED) \
     error(BINDING_C__C2CPP_ENUM_TRANSLATION_INVALID_SUBSCRIBER_EVENT_VALUE) \

iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor.inl

@@ -137,13 +137,11 @@ inline void ChunkDistributor<ChunkDistributorDataType>::deliverToAllStoredQueues
     {
         typename MemberType_t::LockGuard_t lock(*getMembers());
 
-        bool willWaitForSubscriber =
-            getMembers()->m_subscriberTooSlowPolicy == SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER;
+        bool willWaitForConsumer = getMembers()->m_consumerTooSlowPolicy == ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER;
         // send to all the queues
         for (auto& queue : getMembers()->m_queues)
         {
-            bool isBlockingQueue =
-                (willWaitForSubscriber && queue->m_queueFullPolicy == QueueFullPolicy::BLOCK_PRODUCER);
+            bool isBlockingQueue = (willWaitForConsumer && queue->m_queueFullPolicy == QueueFullPolicy::BLOCK_PRODUCER);
 
             if (!pushToQueue(queue.get(), chunk))
             {
@@ -227,10 +225,9 @@ ChunkDistributor<ChunkDistributorDataType>::deliverToQueue(const cxx::UniqueId u
 
         auto& queue = getMembers()->m_queues[queueIndex.value()];
 
-        bool willWaitForSubscriber =
-            getMembers()->m_subscriberTooSlowPolicy == SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER;
+        bool willWaitForConsumer = getMembers()->m_consumerTooSlowPolicy == ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER;
 
-        bool isBlockingQueue = (willWaitForSubscriber && queue->m_queueFullPolicy == QueueFullPolicy::BLOCK_PRODUCER);
+        bool isBlockingQueue = (willWaitForConsumer && queue->m_queueFullPolicy == QueueFullPolicy::BLOCK_PRODUCER);
 
         retry = false;
         if (!pushToQueue(queue.get(), chunk))

iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor_data.hpp

@@ -44,7 +44,7 @@ struct ChunkDistributorData : public LockingPolicy
     using ChunkQueueData_t = typename ChunkQueuePusherType::MemberType_t;
     using ChunkDistributorDataProperties_t = ChunkDistributorDataProperties;
 
-    ChunkDistributorData(const SubscriberTooSlowPolicy policy, const uint64_t historyCapacity = 0u) noexcept;
+    ChunkDistributorData(const ConsumerTooSlowPolicy policy, const uint64_t historyCapacity = 0u) noexcept;
 
     const uint64_t m_historyCapacity;
 
@@ -59,7 +59,7 @@ struct ChunkDistributorData : public LockingPolicy
     using HistoryContainer_t =
         cxx::vector<mepoo::ShmSafeUnmanagedChunk, ChunkDistributorDataProperties_t::MAX_HISTORY_CAPACITY>;
     HistoryContainer_t m_history;
-    const SubscriberTooSlowPolicy m_subscriberTooSlowPolicy;
+    const ConsumerTooSlowPolicy m_consumerTooSlowPolicy;
 };
 
 } // namespace popo

iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor_data.inl

@@ -32,10 +32,10 @@ constexpr T min(const T left, const T right) noexcept
 
 template <typename ChunkDistributorDataProperties, typename LockingPolicy, typename ChunkQueuePusherType>
 inline ChunkDistributorData<ChunkDistributorDataProperties, LockingPolicy, ChunkQueuePusherType>::ChunkDistributorData(
-    const SubscriberTooSlowPolicy policy, const uint64_t historyCapacity) noexcept
+    const ConsumerTooSlowPolicy policy, const uint64_t historyCapacity) noexcept
     : LockingPolicy()
     , m_historyCapacity(min(historyCapacity, ChunkDistributorDataProperties_t::MAX_HISTORY_CAPACITY))
-    , m_subscriberTooSlowPolicy(policy)
+    , m_consumerTooSlowPolicy(policy)
 {
     if (m_historyCapacity != historyCapacity)
     {

iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_sender_data.hpp

@@ -33,7 +33,7 @@ template <uint32_t MaxChunksAllocatedSimultaneously, typename ChunkDistributorDa
 struct ChunkSenderData : public ChunkDistributorDataType
 {
     explicit ChunkSenderData(cxx::not_null<mepoo::MemoryManager* const> memoryManager,
-                             const SubscriberTooSlowPolicy subscriberTooSlowPolicy,
+                             const ConsumerTooSlowPolicy consumerTooSlowPolicy,
                              const uint64_t historyCapacity = 0U,
                              const mepoo::MemoryInfo& memoryInfo = mepoo::MemoryInfo()) noexcept;
 

iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_sender_data.inl

@@ -24,10 +24,10 @@ namespace popo
 template <uint32_t MaxChunksAllocatedSimultaneously, typename ChunkDistributorDataType>
 inline ChunkSenderData<MaxChunksAllocatedSimultaneously, ChunkDistributorDataType>::ChunkSenderData(
     cxx::not_null<mepoo::MemoryManager* const> memoryManager,
-    const SubscriberTooSlowPolicy subscriberTooSlowPolicy,
+    const ConsumerTooSlowPolicy consumerTooSlowPolicy,
     const uint64_t historyCapacity,
     const mepoo::MemoryInfo& memoryInfo) noexcept
-    : ChunkDistributorDataType(subscriberTooSlowPolicy, historyCapacity)
+    : ChunkDistributorDataType(consumerTooSlowPolicy, historyCapacity)
     , m_memoryMgr(memoryManager)
     , m_memoryInfo(memoryInfo)
 {

iceoryx_posh/include/iceoryx_posh/popo/publisher_options.hpp

@@ -41,7 +41,7 @@ struct PublisherOptions
     bool offerOnCreate{true};
 
     /// @brief The option whether the publisher should block when the subscriber queue is full
-    SubscriberTooSlowPolicy subscriberTooSlowPolicy{SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA};
+    ConsumerTooSlowPolicy subscriberTooSlowPolicy{ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA};
 
     /// @brief serialization of the PublisherOptions
     cxx::Serialization serialize() const noexcept;

iceoryx_posh/include/iceoryx_posh/runtime/posh_runtime.hpp

@@ -77,7 +77,7 @@ class PoshRuntime
     RuntimeName_t getInstanceName() const noexcept;
 
     /// @brief initiates the shutdown of the runtime to unblock all potentially blocking publisher
-    /// with the SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER option set
+    /// with the ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER option set
     void shutdown() noexcept;
 
     /// @brief request the RouDi daemon to create a publisher port

iceoryx_posh/source/popo/ports/server_port_roudi.cpp

@@ -41,7 +41,7 @@ ServerPortRouDi::MemberType_t* ServerPortRouDi::getMembers() noexcept
 
 ConsumerTooSlowPolicy ServerPortRouDi::getClientTooSlowPolicy() const noexcept
 {
-    return getMembers()->m_chunkSenderData.m_subscriberTooSlowPolicy;
+    return getMembers()->m_chunkSenderData.m_consumerTooSlowPolicy;
 }
 
 cxx::optional<capro::CaproMessage> ServerPortRouDi::tryGetCaProMessage() noexcept