Fixed many clang-tidy warnings

eclipse-ecal · Apr 19, 2024 · f09df3c · f09df3c
1 parent 61b2641
commit f09df3c
Show file tree

Hide file tree

Showing 18 changed files with 76 additions and 28 deletions.
diff --git a/ecaludp/include_with_udpcap/ecaludp/socket_npcap.h b/ecaludp/include_with_udpcap/ecaludp/socket_npcap.h
@@ -90,12 +90,11 @@ namespace ecaludp
     ECALUDP_EXPORT std::shared_ptr<ecaludp::OwningBuffer> receive_from(asio::ip::udp::endpoint& sender_endpoint, ecaludp::Error& error);
 
     ECALUDP_EXPORT void async_receive_from(asio::ip::udp::endpoint& sender_endpoint
-                                  , const std::function<void(const std::shared_ptr<ecaludp::OwningBuffer>&, ecaludp::Error)>& completion_handler);
-
+                                  , const std::function<void(const std::shared_ptr<ecaludp::OwningBuffer>&, const ecaludp::Error&)>& completion_handler);
 
   private:
     void receive_next_datagram_from(asio::ip::udp::endpoint& sender_endpoint
-                                  , const std::function<void(const std::shared_ptr<ecaludp::OwningBuffer>&, ecaludp::Error)>& completion_handler);
+                                  , const std::function<void(const std::shared_ptr<ecaludp::OwningBuffer>&, const ecaludp::Error&)>& completion_handler);
 
     std::shared_ptr<ecaludp::OwningBuffer> handle_datagram(const std::shared_ptr<ecaludp::RawMemory>&     buffer
                                                         , const std::shared_ptr<asio::ip::udp::endpoint>& sender_endpoint

diff --git a/ecaludp/src/async_udpcap_socket.cpp b/ecaludp/src/async_udpcap_socket.cpp
@@ -72,7 +72,7 @@ namespace ecaludp
                                           , size_t               max_buffer_size
                                           , Udpcap::HostAddress& sender_address
                                           , uint16_t&            sender_port
-                                          , const std::function<void(ecaludp::Error&, size_t)>& read_handler)
+                                          , const std::function<void(const ecaludp::Error&, size_t)>& read_handler)
   {
     const std::unique_lock<std::mutex> lock(wait_thread_trigger_mutex_);
     async_receive_from_parameters_queue_.push_back({ buffer, max_buffer_size, &sender_address, &sender_port, read_handler });

diff --git a/ecaludp/src/async_udpcap_socket.h b/ecaludp/src/async_udpcap_socket.h
@@ -68,13 +68,13 @@ namespace ecaludp
                       , size_t               max_buffer_size
                       , Udpcap::HostAddress& sender_address
                       , uint16_t&            sender_port
-                      , ecaludp::Error&       error);
+                      , ecaludp::Error&      error);
 
     void asyncReceiveFrom( char*                buffer
                          , size_t               max_buffer_size
                          , Udpcap::HostAddress& sender_address
                          , uint16_t&            sender_port
-                         , const std::function<void(ecaludp::Error&, size_t)>& read_handler);
+                         , const std::function<void(const ecaludp::Error&, size_t)>& read_handler);
 
   private:
     static void toEcaludpError(const Udpcap::Error& udpcap_error, ecaludp::Error& ecaludp_error);
@@ -95,7 +95,7 @@ namespace ecaludp
       size_t                max_buffer_size_;
       Udpcap::HostAddress*  sender_address_;
       uint16_t*             sender_port_;
-      std::function<void(ecaludp::Error&, size_t)> read_handler_;
+      std::function<void(const ecaludp::Error&, size_t)> read_handler_;
     };
 
     Udpcap::UdpcapSocket         udpcap_socket_;

diff --git a/ecaludp/src/socket_npcap.cpp b/ecaludp/src/socket_npcap.cpp
@@ -141,13 +141,13 @@ namespace ecaludp
 
 
   void SocketNpcap::async_receive_from(asio::ip::udp::endpoint& sender_endpoint
-                                      , const std::function<void(const std::shared_ptr<ecaludp::OwningBuffer>&, ecaludp::Error)>& completion_handler)
+                                      , const std::function<void(const std::shared_ptr<ecaludp::OwningBuffer>&, const ecaludp::Error&)>& completion_handler)
   {
     receive_next_datagram_from(sender_endpoint, completion_handler);
   }
 
   void SocketNpcap::receive_next_datagram_from(asio::ip::udp::endpoint& sender_endpoint
-                                              , const std::function<void(const std::shared_ptr<ecaludp::OwningBuffer>&, ecaludp::Error)>& completion_handler)
+                                              , const std::function<void(const std::shared_ptr<ecaludp::OwningBuffer>&, const ecaludp::Error&)>& completion_handler)
 
   {
     auto datagram_buffer = datagram_buffer_pool_->allocate();
@@ -164,7 +164,7 @@ namespace ecaludp
                             , buffer->size()
                             , *sender_address
                             , *sender_port
-                            , [this, buffer, completion_handler, sender_address, sender_port, &sender_endpoint](ecaludp::Error& error, size_t bytes_received)
+                            , [this, buffer, completion_handler, sender_address, sender_port, &sender_endpoint](const ecaludp::Error& error, size_t bytes_received)
                               {
                                 if (error)
                                 {

diff --git a/samples/ecaludp_perftool/src/receiver.h b/samples/ecaludp_perftool/src/receiver.h
@@ -29,6 +29,12 @@ class Receiver
   Receiver(const ReceiverParameters& parameters);
   virtual ~Receiver();
 
+  // disable copy and move
+  Receiver(const Receiver&) = delete;
+  Receiver(Receiver&&) = delete;
+  Receiver& operator=(const Receiver&) = delete;
+  Receiver& operator=(Receiver&&) = delete;
+
   virtual void start() = 0;
 
 private:

diff --git a/samples/ecaludp_perftool/src/receiver_async.cpp b/samples/ecaludp_perftool/src/receiver_async.cpp
@@ -49,7 +49,8 @@ ReceiverAsync::~ReceiverAsync()
   if(work_)
     work_.reset();
 
-  io_context_thread_->join();
+  if (io_context_thread_->joinable())
+    io_context_thread_->join();
 }
 
 void ReceiverAsync::start()
@@ -82,7 +83,7 @@ void ReceiverAsync::receive_message()
                               {
                                 if (ec)
                                 {
-                                  std::cout << "Error sending: " << ec.message() << '\n';
+                                  std::cerr << "Error sending: " << ec.message() << '\n';
                                   socket_->close();
                                   return;
                                 }

diff --git a/samples/ecaludp_perftool/src/receiver_async.h b/samples/ecaludp_perftool/src/receiver_async.h
@@ -32,6 +32,12 @@ class ReceiverAsync : public Receiver
     ReceiverAsync(const ReceiverParameters& parameters);
     ~ReceiverAsync() override;
 
+    // disable copy and move
+    ReceiverAsync(const ReceiverAsync&) = delete;
+    ReceiverAsync(ReceiverAsync&&) = delete;
+    ReceiverAsync& operator=(const ReceiverAsync&) = delete;
+    ReceiverAsync& operator=(ReceiverAsync&&) = delete;
+
     void start() override;
 
   private:

diff --git a/samples/ecaludp_perftool/src/receiver_npcap_async.cpp b/samples/ecaludp_perftool/src/receiver_npcap_async.cpp
@@ -30,7 +30,7 @@
 ReceiverNpcapAsync::ReceiverNpcapAsync(const ReceiverParameters& parameters)
   : Receiver(parameters)
 {
-  std::cout << "Receiver implementation: Asynchronous NPCAP" << std::endl;
+  std::cout << "Receiver implementation: Asynchronous NPCAP\n";
 }
 
 ReceiverNpcapAsync::~ReceiverNpcapAsync()
@@ -49,7 +49,7 @@ void ReceiverNpcapAsync::start()
   }
   catch (const std::exception& e)
   {
-    std::cerr << "Error creating socket: " << e.what() << std::endl;
+    std::cerr << "Error creating socket: " << e.what()<< '\n';
     exit(1);
   }
 
@@ -61,17 +61,17 @@ void ReceiverNpcapAsync::receive_message()
   auto endpoint = std::make_shared<asio::ip::udp::endpoint>();
 
   socket_->async_receive_from(*endpoint,
-                              [this, endpoint](const std::shared_ptr<ecaludp::OwningBuffer>& message, ecaludp::Error& error)
+                              [this, endpoint](const std::shared_ptr<ecaludp::OwningBuffer>& message, const ecaludp::Error& error)
                               {
                                 if (error)
                                 {
-                                  std::cout << "Error sending: " << error.ToString() << std::endl;
+                                  std::cerr << "Error sending: " << error.ToString()<< '\n';
                                   socket_->close();
                                   return;
                                 }
 
                                 {
-                                  std::unique_lock<std::mutex> lock(statistics_mutex_);
+                                  const std::lock_guard<std::mutex> lock(statistics_mutex_);
 
                                   bytes_payload_     += message->size();
                                   messages_received_ ++;

diff --git a/samples/ecaludp_perftool/src/receiver_npcap_async.h b/samples/ecaludp_perftool/src/receiver_npcap_async.h
@@ -31,6 +31,12 @@ class ReceiverNpcapAsync : public Receiver
     ReceiverNpcapAsync(const ReceiverParameters& parameters);
     ~ReceiverNpcapAsync() override;
 
+    // disable copy and move
+    ReceiverNpcapAsync(const ReceiverNpcapAsync&) = delete;
+    ReceiverNpcapAsync(ReceiverNpcapAsync&&) = delete;
+    ReceiverNpcapAsync& operator=(const ReceiverNpcapAsync&) = delete;
+    ReceiverNpcapAsync& operator=(ReceiverNpcapAsync&&) = delete;
+
     void start() override;
 
   private:

diff --git a/samples/ecaludp_perftool/src/receiver_npcap_sync.cpp b/samples/ecaludp_perftool/src/receiver_npcap_sync.cpp
@@ -30,7 +30,7 @@
 ReceiverNpcapSync::ReceiverNpcapSync(const ReceiverParameters& parameters)
   : Receiver(parameters)
 {
-  std::cout << "Receiver implementation: Synchronous NPCAP" << std::endl;
+  std::cout << "Receiver implementation: Synchronous NPCAP\n";
 }
 
 ReceiverNpcapSync::~ReceiverNpcapSync()
@@ -55,7 +55,7 @@ void ReceiverNpcapSync::receive_loop()
   }
   catch (const std::exception& e)
   {
-    std::cerr << "Error creating socket: " << e.what() << std::endl;
+    std::cerr << "Error creating socket: " << e.what()<< '\n';
     exit(1);
   }
 
@@ -69,12 +69,12 @@ void ReceiverNpcapSync::receive_loop()
 
       if (error)
       {
-        std::cerr << "Error receiving message: " << error.ToString() << std::endl;
+        std::cerr << "Error receiving message: " << error.ToString()<< '\n';
         break;
       }
 
       {
-        std::unique_lock<std::mutex> lock(statistics_mutex_);
+        const std::lock_guard<std::mutex> lock(statistics_mutex_);
 
         if (is_stopped_)
           break;

diff --git a/samples/ecaludp_perftool/src/receiver_npcap_sync.h b/samples/ecaludp_perftool/src/receiver_npcap_sync.h
@@ -27,6 +27,12 @@ class ReceiverNpcapSync : public Receiver
     ReceiverNpcapSync(const ReceiverParameters& parameters);
     ~ReceiverNpcapSync() override;
 
+    // disable copy and move
+    ReceiverNpcapSync(const ReceiverNpcapSync&) = delete;
+    ReceiverNpcapSync(ReceiverNpcapSync&&) = delete;
+    ReceiverNpcapSync& operator=(const ReceiverNpcapSync&) = delete;
+    ReceiverNpcapSync& operator=(ReceiverNpcapSync&&) = delete;
+
     void start() override;
 
   private:

diff --git a/samples/ecaludp_perftool/src/receiver_sync.h b/samples/ecaludp_perftool/src/receiver_sync.h
@@ -28,6 +28,12 @@ class ReceiverSync : public Receiver
     ReceiverSync(const ReceiverParameters& parameters);
     ~ReceiverSync() override;
 
+    // disable copy and move
+    ReceiverSync(const ReceiverSync&) = delete;
+    ReceiverSync(ReceiverSync&&) = delete;
+    ReceiverSync& operator=(const ReceiverSync&) = delete;
+    ReceiverSync& operator=(ReceiverSync&&) = delete;
+
     void start() override;
 
   private:

diff --git a/samples/ecaludp_perftool/src/sender.h b/samples/ecaludp_perftool/src/sender.h
@@ -29,6 +29,12 @@ class Sender
   Sender(const SenderParameters& parameters);
   virtual ~Sender();
 
+  // disable copy and move
+  Sender(const Sender&) = delete;
+  Sender(Sender&&) = delete;
+  Sender& operator=(const Sender&) = delete;
+  Sender& operator=(Sender&&) = delete;
+
   virtual void start() = 0;
 
 private:

diff --git a/samples/ecaludp_perftool/src/sender_async.cpp b/samples/ecaludp_perftool/src/sender_async.cpp
@@ -46,7 +46,8 @@ SenderAsync::~SenderAsync()
       std::cerr << "Error cancelling socket: " << ec.message() << '\n';
   }
 
-  io_context_thread_->join();
+  if(io_context_thread_->joinable())
+    io_context_thread_->join();
 }
 
 void SenderAsync::start() 
@@ -78,7 +79,7 @@ void SenderAsync::send_message(const std::shared_ptr<const std::string>& message
                           {
                             if (ec)
                             {
-                              std::cout << "Error sending: " << ec.message() << '\n';
+                              std::cerr << "Error sending: " << ec.message() << '\n';
                               socket_->close();
                               return;
                             }

diff --git a/samples/ecaludp_perftool/src/sender_async.h b/samples/ecaludp_perftool/src/sender_async.h
@@ -33,6 +33,12 @@ class SenderAsync : public Sender
     SenderAsync(const SenderParameters& parameters);
     ~SenderAsync() override;
 
+    // disable copy and move
+    SenderAsync(const SenderAsync&) = delete;
+    SenderAsync(SenderAsync&&) = delete;
+    SenderAsync& operator=(const SenderAsync&) = delete;
+    SenderAsync& operator=(SenderAsync&&) = delete;
+
     void start() override;
 
   private:

diff --git a/samples/ecaludp_perftool/src/sender_sync.h b/samples/ecaludp_perftool/src/sender_sync.h
@@ -28,6 +28,12 @@ class SenderSync : public Sender
     SenderSync(const SenderParameters& parameters);
     ~SenderSync() override;
 
+    // disable copy and move
+    SenderSync(const SenderSync&) = delete;
+    SenderSync(SenderSync&&) = delete;
+    SenderSync& operator=(const SenderSync&) = delete;
+    SenderSync& operator=(SenderSync&&) = delete;
+
     void start() override;
 
   private:

diff --git a/samples/ecaludp_perftool/src/socket_builder_npcap.cpp b/samples/ecaludp_perftool/src/socket_builder_npcap.cpp
@@ -44,18 +44,17 @@ namespace SocketBuilderNpcap
     // Set receive buffer size
     if (parameters.buffer_size > 0)
     {
-      asio::socket_base::receive_buffer_size option(parameters.buffer_size);
-      bool success = socket->set_receive_buffer_size(parameters.buffer_size);
+      const bool success = socket->set_receive_buffer_size(parameters.buffer_size);
       if (!success)
       {
         throw std::runtime_error("Failed to set receive buffer size");
       }
     }
 
-    asio::ip::udp::endpoint destination(ip_address, parameters.port);
+    const asio::ip::udp::endpoint destination(ip_address, parameters.port);
 
     {
-      bool success = socket->bind(destination);
+      const bool success = socket->bind(destination);
       if (!success)
       {
         throw std::runtime_error("Failed to bind socket");

diff --git a/samples/ecaludp_sample_npcap/src/main.cpp b/samples/ecaludp_sample_npcap/src/main.cpp
@@ -67,7 +67,7 @@ void receive_package()
   auto sender_endpoint = std::make_shared<asio::ip::udp::endpoint>();
 
   receive_socket_->async_receive_from(*sender_endpoint
-                              , [sender_endpoint](const std::shared_ptr<ecaludp::OwningBuffer>& buffer, ecaludp::Error& error)
+                              , [sender_endpoint](const std::shared_ptr<ecaludp::OwningBuffer>& buffer, const ecaludp::Error& error)
                                 {
                                   if (error)
                                   {