iox-#2408 clang format node experimental client, server

Author: jmyvalour

iceoryx_posh/experimental/include/iox/posh/experimental/client.hpp

@@ -19,20 +19,20 @@
 
 #include "iceoryx_posh/iceoryx_posh_types.hpp"
 #include "iceoryx_posh/internal/runtime/posh_runtime_impl.hpp"
-#include <iceoryx_posh/popo/client.hpp>
-#include <iceoryx_posh/popo/untyped_client.hpp>
+#include "iceoryx_posh/popo/client.hpp"
+#include "iceoryx_posh/popo/untyped_client.hpp"
 #include "iox/builder.hpp"
 #include "iox/expected.hpp"
 #include "iox/unique_ptr.hpp"
 
 namespace iox::posh::experimental
 {
 
+using iox::popo::Client;
 using iox::popo::ClientChunkQueueData_t;
 using iox::popo::ConsumerTooSlowPolicy;
 using iox::popo::QueueFullPolicy;
 using iox::popo::UntypedClient;
-using iox::popo::Client;
 
 enum class ClientBuilderError : uint8_t
 {
@@ -78,7 +78,7 @@ class ClientBuilder
   private:
     friend class Node;
     explicit ClientBuilder(runtime::PoshRuntime& runtime,
-                               const capro::ServiceDescription& service_description) noexcept;
+                           const capro::ServiceDescription& service_description) noexcept;
 
   private:
     // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members) Intentionally used since the ClientBuilder is not intended to be moved

iceoryx_posh/experimental/include/iox/posh/experimental/detail/client.inl

@@ -22,7 +22,7 @@
 namespace iox::posh::experimental
 {
 inline ClientBuilder::ClientBuilder(runtime::PoshRuntime& runtime,
-                                            const capro::ServiceDescription& service_description) noexcept
+                                    const capro::ServiceDescription& service_description) noexcept
     : m_runtime(runtime)
     , m_service_description(service_description)
 {
@@ -32,7 +32,8 @@ template <typename Req, typename Res>
 inline expected<unique_ptr<Client<Req, Res>>, ClientBuilderError> ClientBuilder::create() noexcept
 {
     auto* client_port_data = m_runtime.getMiddlewareClient(
-        m_service_description, {m_response_queue_capacity, "", m_connect_on_create, m_response_queue_full_policy, m_server_too_slow_policy});
+        m_service_description,
+        {m_response_queue_capacity, "", m_connect_on_create, m_response_queue_full_policy, m_server_too_slow_policy});
     if (client_port_data == nullptr)
     {
         return err(ClientBuilderError::OUT_OF_RESOURCES);
@@ -47,13 +48,15 @@ inline expected<unique_ptr<Client<Req, Res>>, ClientBuilderError> ClientBuilder:
 inline expected<unique_ptr<iox::popo::UntypedClient>, ClientBuilderError> ClientBuilder::create() noexcept
 {
     auto* client_port_data = m_runtime.getMiddlewareClient(
-        m_service_description, {m_response_queue_capacity, "", m_connect_on_create, m_response_queue_full_policy, m_server_too_slow_policy});
+        m_service_description,
+        {m_response_queue_capacity, "", m_connect_on_create, m_response_queue_full_policy, m_server_too_slow_policy});
     if (client_port_data == nullptr)
     {
         return err(ClientBuilderError::OUT_OF_RESOURCES);
     }
     return ok(unique_ptr<iox::popo::UntypedClient>{
-        new (std::nothrow) iox::popo::UntypedClient{iox::popo::ClientPortUser{*client_port_data}}, [&](auto* const client) {
+        new (std::nothrow) iox::popo::UntypedClient{iox::popo::ClientPortUser{*client_port_data}},
+        [&](auto* const client) {
             // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) raw pointer is required by the unique_ptr API
             delete client;
         }});

iceoryx_posh/experimental/include/iox/posh/experimental/detail/server.inl

@@ -22,7 +22,7 @@
 namespace iox::posh::experimental
 {
 inline ServerBuilder::ServerBuilder(runtime::PoshRuntime& runtime,
-                                            const capro::ServiceDescription& service_description) noexcept
+                                    const capro::ServiceDescription& service_description) noexcept
     : m_runtime(runtime)
     , m_service_description(service_description)
 {
@@ -33,7 +33,8 @@ template <typename Req, typename Res>
 inline expected<unique_ptr<Server<Req, Res>>, ServerBuilderError> ServerBuilder::create() noexcept
 {
     auto* server_port_data = m_runtime.getMiddlewareServer(
-        m_service_description, {m_request_queue_capacity, "", m_offer_on_create, m_request_queue_full_policy, m_client_too_slow_policy});
+        m_service_description,
+        {m_request_queue_capacity, "", m_offer_on_create, m_request_queue_full_policy, m_client_too_slow_policy});
     if (server_port_data == nullptr)
     {
         return err(ServerBuilderError::OUT_OF_RESOURCES);
@@ -48,16 +49,17 @@ inline expected<unique_ptr<Server<Req, Res>>, ServerBuilderError> ServerBuilder:
 inline expected<unique_ptr<UntypedServer>, ServerBuilderError> ServerBuilder::create() noexcept
 {
     auto* server_port_data = m_runtime.getMiddlewareServer(
-        m_service_description, {m_request_queue_capacity, "", m_offer_on_create, m_request_queue_full_policy, m_client_too_slow_policy});
+        m_service_description,
+        {m_request_queue_capacity, "", m_offer_on_create, m_request_queue_full_policy, m_client_too_slow_policy});
     if (server_port_data == nullptr)
     {
         return err(ServerBuilderError::OUT_OF_RESOURCES);
     }
-    return ok(unique_ptr<UntypedServer>{
-        new (std::nothrow) UntypedServer{iox::popo::ServerPortUser{*server_port_data}}, [&](auto* const server) {
-            // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) raw pointer is required by the unique_ptr API
-            delete server;
-        }});
+    return ok(unique_ptr<UntypedServer>{new (std::nothrow) UntypedServer{iox::popo::ServerPortUser{*server_port_data}},
+                                        [&](auto* const server) {
+                                            // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) raw pointer is required by the unique_ptr API
+                                            delete server;
+                                        }});
 }
 
 } // namespace iox::posh::experimental

iceoryx_posh/experimental/include/iox/posh/experimental/node.hpp

@@ -26,10 +26,10 @@
 #include "iox/builder.hpp"
 #include "iox/expected.hpp"
 #include "iox/optional.hpp"
+#include "iox/posh/experimental/client.hpp"
 #include "iox/posh/experimental/publisher.hpp"
-#include "iox/posh/experimental/subscriber.hpp"
 #include "iox/posh/experimental/server.hpp"
-#include "iox/posh/experimental/client.hpp"
+#include "iox/posh/experimental/subscriber.hpp"
 #include "iox/posh/experimental/wait_set.hpp"
 #include "iox/unique_ptr.hpp"
 
@@ -141,11 +141,7 @@ class Node
          runtime::IpcRuntimeInterface&& runtime_interface,
          optional<runtime::SharedMemoryUser>&&) noexcept;
 
-    static iox::runtime::PoshRuntime& getNodeRuntime([[maybe_unused]] optional<const RuntimeName_t*> name)
-    {
-        IOX_ASSERT(s_defaultRuntime, "Node Default Runtime has not been created");
-        return *Node::s_defaultRuntime;
-    }
+    static iox::runtime::PoshRuntime& getNodeRuntime([[maybe_unused]] optional<const RuntimeName_t*> name);
 
   private:
     unique_ptr<runtime::PoshRuntime> m_runtime;

iceoryx_posh/experimental/include/iox/posh/experimental/server.hpp

@@ -20,18 +20,18 @@
 #include "iceoryx_posh/iceoryx_posh_types.hpp"
 #include "iceoryx_posh/internal/runtime/posh_runtime_impl.hpp"
 #include "iceoryx_posh/popo/server.hpp"
-#include <iceoryx_posh/popo/untyped_server.hpp>
 #include "iox/builder.hpp"
 #include "iox/expected.hpp"
 #include "iox/unique_ptr.hpp"
+#include <iceoryx_posh/popo/untyped_server.hpp>
 
 namespace iox::posh::experimental
 {
 
-using iox::popo::ServerChunkQueueData_t;
 using iox::popo::ConsumerTooSlowPolicy;
 using iox::popo::QueueFullPolicy;
 using iox::popo::Server;
+using iox::popo::ServerChunkQueueData_t;
 using iox::popo::UntypedServer;
 
 enum class ServerBuilderError : uint8_t
@@ -77,7 +77,7 @@ class ServerBuilder
   private:
     friend class Node;
     explicit ServerBuilder(runtime::PoshRuntime& runtime,
-                               const capro::ServiceDescription& service_description) noexcept;
+                           const capro::ServiceDescription& service_description) noexcept;
 
   private:
     // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members) Intentionally used since the ServerBuilder is not intended to be moved

iceoryx_posh/experimental/source/node.cpp

@@ -172,4 +172,10 @@ WaitSetBuilder Node::wait_set() noexcept
     return WaitSetBuilder{*m_runtime.get()};
 }
 
+iox::runtime::PoshRuntime& Node::getNodeRuntime([[maybe_unused]] optional<const RuntimeName_t*> name)
+{
+    IOX_ASSERT(s_defaultRuntime, "Node Default Runtime has not been created");
+    return *Node::s_defaultRuntime;
+}
+
 } // namespace iox::posh::experimental

iceoryx_posh/test/integrationtests/test_posh_experimental_node.cpp

@@ -627,7 +627,8 @@ TEST(Node_test, CreatingUntypedServer)
     auto domainId = iox::DomainId(1);
     RouDiEnv roudi(domainId);
 
-    auto node = RouDiEnvNodeBuilder("hypnotoad").domain_id(domainId).create().expect("Creating a node should not fail!");
+    auto node =
+        RouDiEnvNodeBuilder("hypnotoad").domain_id(domainId).create().expect("Creating a node should not fail!");
 
     auto server = node.server({"all", "glory", "hypnotoad"}).offer_on_create(true).create();
     ASSERT_FALSE(server.has_error());
@@ -637,19 +638,22 @@ TEST(Node_test, CreatingServer)
 {
     ::testing::Test::RecordProperty("TEST_ID", "e422d450-7e1b-4435-b9ff-d0b0530f8f45");
 
-    struct Request {
+    struct Request
+    {
         uint32_t valueA;
         uint32_t valueB;
     };
 
-    struct Response {
+    struct Response
+    {
         uint32_t sum;
     };
 
     auto domainId = iox::DomainId(1);
     RouDiEnv roudi(domainId);
 
-    auto node = RouDiEnvNodeBuilder("hypnotoad").domain_id(domainId).create().expect("Creating a node should not fail!");
+    auto node =
+        RouDiEnvNodeBuilder("hypnotoad").domain_id(domainId).create().expect("Creating a node should not fail!");
     auto server = node.server({"all", "glory", "hypnotoad"}).offer_on_create(true).create<Request, Response>();
     ASSERT_FALSE(server.has_error());
 }
@@ -661,7 +665,8 @@ TEST(Node_test, CreatingUntypedClient)
     auto domainId = iox::DomainId(1);
     RouDiEnv roudi(domainId);
 
-    auto node = RouDiEnvNodeBuilder("hypnotoad").domain_id(domainId).create().expect("Creating a node should not fail!");
+    auto node =
+        RouDiEnvNodeBuilder("hypnotoad").domain_id(domainId).create().expect("Creating a node should not fail!");
 
     auto client = node.client({"all", "glory", "hypnotoad"}).connect_on_create(false).create();
     ASSERT_FALSE(client.has_error());
@@ -671,19 +676,22 @@ TEST(Node_test, CreatingClient)
 {
     ::testing::Test::RecordProperty("TEST_ID", "290badda-a938-46b8-87ff-b4998ce43d95");
 
-    struct Request {
+    struct Request
+    {
         uint32_t valueA;
         uint32_t valueB;
     };
 
-    struct Response {
+    struct Response
+    {
         uint32_t sum;
     };
 
     auto domainId = iox::DomainId(1);
     RouDiEnv roudi(domainId);
 
-    auto node = RouDiEnvNodeBuilder("hypnotoad").domain_id(domainId).create().expect("Creating a node should not fail!");
+    auto node =
+        RouDiEnvNodeBuilder("hypnotoad").domain_id(domainId).create().expect("Creating a node should not fail!");
 
     auto client = node.client({"all", "glory", "hypnotoad"}).connect_on_create(false).create<Request, Response>();
     ASSERT_FALSE(client.has_error());
@@ -693,12 +701,14 @@ TEST(Node_test, UntypedServerClientRequestResponse)
 {
     ::testing::Test::RecordProperty("TEST_ID", "38c02027-f2e5-47cf-9771-65868525647a");
 
-    struct Request {
+    struct Request
+    {
         uint32_t valueA;
         uint32_t valueB;
     };
 
-    struct Response {
+    struct Response
+    {
         uint32_t sum;
     };
 
@@ -720,41 +730,46 @@ TEST(Node_test, UntypedServerClientRequestResponse)
             auto request = static_cast<Request*>(requestPayload);
             request->valueA = 4;
             request->valueB = 10;
-            client->send(request)
-                .or_else([&](auto& error) { GTEST_FAIL() << "Client: Could not send request: " << error; });
+            client->send(request).or_else(
+                [&](auto& error) { GTEST_FAIL() << "Client: Could not send request: " << error; });
         })
-        .or_else([&](auto& error) {GTEST_FAIL() << "Client: Could not allocate data request: " << error; });
+        .or_else([&](auto& error) { GTEST_FAIL() << "Client: Could not allocate data request: " << error; });
 
     GTEST_ASSERT_EQ(client->getConnectionState(), iox::ConnectionState::CONNECTED);
 
-    server->take().and_then([&](const auto& requestPayload) {
-        auto request = static_cast<const Request*>(requestPayload);
-        const iox::popo::RequestHeader* requestHeader = iox::popo::RequestHeader::fromPayload(requestPayload);
-
-        GTEST_ASSERT_EQ(requestHeader->getSequenceId(), 1);
-        server->loan(requestHeader, sizeof(Response), alignof(Response))
-            .and_then([&](auto& responsePayload) {
-                auto response = static_cast<Response*>(responsePayload);
-                response->sum = request->valueA + request->valueB;
-                server->send(response).or_else(
-                    [&](auto& error) {  GTEST_FAIL() << "Server: Could not send Response: " << error << std::endl; });
-            })
-            .or_else([](auto& error) { GTEST_FAIL() << "Server: Could not allocate response: " << error; });
-    }).or_else([](iox::popo::ServerRequestResult result) {
-        GTEST_FAIL() << "Server: Could not get request: " << iox::popo::asStringLiteral(result);
-    });
+    server->take()
+        .and_then([&](const auto& requestPayload) {
+            auto request = static_cast<const Request*>(requestPayload);
+            const iox::popo::RequestHeader* requestHeader = iox::popo::RequestHeader::fromPayload(requestPayload);
+
+            GTEST_ASSERT_EQ(requestHeader->getSequenceId(), 1);
+            server->loan(requestHeader, sizeof(Response), alignof(Response))
+                .and_then([&](auto& responsePayload) {
+                    auto response = static_cast<Response*>(responsePayload);
+                    response->sum = request->valueA + request->valueB;
+                    server->send(response).or_else([&](auto& error) {
+                        GTEST_FAIL() << "Server: Could not send Response: " << error << std::endl;
+                    });
+                })
+                .or_else([](auto& error) { GTEST_FAIL() << "Server: Could not allocate response: " << error; });
+        })
+        .or_else([](iox::popo::ServerRequestResult result) {
+            GTEST_FAIL() << "Server: Could not get request: " << iox::popo::asStringLiteral(result);
+        });
 
     GTEST_ASSERT_EQ(client->hasResponses(), true);
 
-    client->take().and_then([&](const auto& responsePayload) {
-        auto responseHeader = iox::popo::ResponseHeader::fromPayload(responsePayload);
-        GTEST_ASSERT_EQ(responseHeader->getSequenceId(), 1);
-        auto response = static_cast<const Response*>(responsePayload);
-        GTEST_ASSERT_EQ(response->sum, 14);
-        client->releaseResponse(responsePayload);
-    }).or_else([](iox::popo::ChunkReceiveResult result) {
-        GTEST_FAIL() << "Client: Could not get response: " << iox::popo::asStringLiteral(result);
-    });
+    client->take()
+        .and_then([&](const auto& responsePayload) {
+            auto responseHeader = iox::popo::ResponseHeader::fromPayload(responsePayload);
+            GTEST_ASSERT_EQ(responseHeader->getSequenceId(), 1);
+            auto response = static_cast<const Response*>(responsePayload);
+            GTEST_ASSERT_EQ(response->sum, 14);
+            client->releaseResponse(responsePayload);
+        })
+        .or_else([](iox::popo::ChunkReceiveResult result) {
+            GTEST_FAIL() << "Client: Could not get response: " << iox::popo::asStringLiteral(result);
+        });
 }
 
 } // namespace