update error messages

Author: alejandrofsevilla

CMakeLists.txt

@@ -1,5 +1,7 @@
 cmake_minimum_required(VERSION 3.22.0)
 
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
 project(boost-tcp-server-client LANGUAGES CXX)
 
 add_subdirectory(tests)

TcpClient.cpp

@@ -19,21 +19,20 @@ void TcpClient::connect(const boost::asio::ip::tcp::endpoint &endpoint) {
   auto socket = std::make_shared<boost::asio::ip::tcp::socket>(m_ioContext);
   socket->async_connect(endpoint, [this, socket](const auto &error) {
     if (error) {
-      std::cerr << "TcpClient::connect() found error: " + error.message()
-                << std::endl;
+      std::cerr << "TcpClient::connect() error: " + error.message() + ".\n";
       m_observer.onDisconnected();
       return;
     }
     m_connection = TcpConnection::create(std::move(*socket), *this);
     m_connection->startReading();
-    std::cout << "TCP Client was connected" << std::endl;
+    std::cout << "TCPClient connected.\n";
     m_observer.onConnected();
   });
 }
 
 void TcpClient::send(const char *data, size_t size) {
   if (!m_connection) {
-    std::cerr << "TcpClient::send() found error: no connection" << std::endl;
+    std::cerr << "TcpClient::send() error: no connection.\n";
     return;
   }
   m_connection->send(data, size);
@@ -53,7 +52,7 @@ void TcpClient::onReceived([[maybe_unused]] int connectionId, const char *data,
 void TcpClient::onConnectionClosed([[maybe_unused]] int connectionId) {
   if (m_connection) {
     m_connection.reset();
-    std::cout << "TCP Client was disconnected" << std::endl;
+    std::cout << "TCPClient disconnected.\n";
     m_observer.onDisconnected();
   }
 }

TcpConnection.cpp

@@ -4,7 +4,7 @@
 
 namespace {
 constexpr auto f_maxPackageSize{1024};
-}  // namespace
+} // namespace
 
 void TcpConnection::Observer::onReceived([[maybe_unused]] int connectionId,
                                          [[maybe_unused]] const char *data,
@@ -15,17 +15,13 @@ void TcpConnection::Observer::onConnectionClosed(
 
 TcpConnection::TcpConnection(boost::asio::ip::tcp::socket &&socket,
                              Observer &observer, int id)
-    : m_socket{std::move(socket)},
-      m_readBuffer{},
-      m_writeBuffer{},
-      m_writeBufferMutex{},
-      m_observer{observer},
-      m_isReading{false},
-      m_isWritting{false},
-      m_id{id} {}
+    : m_socket{std::move(socket)}, m_readBuffer{}, m_writeBuffer{},
+      m_writeBufferMutex{}, m_observer{observer}, m_isReading{false},
+      m_isWritting{false}, m_id{id} {}
 
-std::shared_ptr<TcpConnection> TcpConnection::create(
-    boost::asio::ip::tcp::socket &&socket, Observer &observer, int id) {
+std::shared_ptr<TcpConnection>
+TcpConnection::create(boost::asio::ip::tcp::socket &&socket, Observer &observer,
+                      int id) {
   return std::shared_ptr<TcpConnection>(
       new TcpConnection{std::move(socket), observer, id});
 }
@@ -50,9 +46,8 @@ void TcpConnection::close() {
     m_socket.cancel();
     m_socket.close();
   } catch (const std::exception &e) {
-    std::cerr << "TcpConnection::Close() caught exception: " +
-                     static_cast<std::string>(e.what())
-              << std::endl;
+    std::cerr << "TcpConnection::close() exception: " +
+                     static_cast<std::string>(e.what()) + ".\n";
     return;
   }
   m_observer.onConnectionClosed(m_id);
@@ -62,20 +57,19 @@ void TcpConnection::doRead() {
   m_isReading = true;
   auto buffers = m_readBuffer.prepare(f_maxPackageSize);
   auto self = shared_from_this();
-  m_socket.async_read_some(
-      buffers, [this, self](const auto &error, auto bytesTransferred) {
-        if (error) {
-          std::cerr << "TcpConnection::doRead() found error: " + error.message()
-                    << std::endl;
-          return close();
-        }
-        m_readBuffer.commit(bytesTransferred);
-        m_observer.onReceived(
-            m_id, static_cast<const char *>(m_readBuffer.data().data()),
-            bytesTransferred);
-        m_readBuffer.consume(bytesTransferred);
-        doRead();
-      });
+  m_socket.async_read_some(buffers, [this, self](const auto &error,
+                                                 auto bytesTransferred) {
+    if (error) {
+      std::cerr << "TcpConnection::doRead() error: " + error.message() + ".\n";
+      return close();
+    }
+    m_readBuffer.commit(bytesTransferred);
+    m_observer.onReceived(m_id,
+                          static_cast<const char *>(m_readBuffer.data().data()),
+                          bytesTransferred);
+    m_readBuffer.consume(bytesTransferred);
+    doRead();
+  });
 }
 
 void TcpConnection::doWrite() {
@@ -85,8 +79,7 @@ void TcpConnection::doWrite() {
                                                       const auto &error,
                                                       auto bytesTransferred) {
     if (error) {
-      std::cerr << "TcpConnection::doWrite() found error: " + error.message()
-                << std::endl;
+      std::cerr << "TcpConnection::doWrite() error: " + error.message() + ".\n";
       return close();
     }
     std::lock_guard<std::mutex> guard{m_writeBufferMutex};

TcpServer.cpp

@@ -14,12 +14,8 @@ void TcpServer::Observer::onConnectionClosed(
     [[maybe_unused]] int connectionId) {}
 
 TcpServer::TcpServer(boost::asio::io_context &ioContext, Observer &observer)
-    : m_acceptor{ioContext},
-      m_connections{},
-      m_observer{observer},
-      m_connectionCount{0},
-      m_isAccepting{false},
-      m_isClosing{false} {}
+    : m_acceptor{ioContext}, m_connections{}, m_observer{observer},
+      m_connectionCount{0}, m_isAccepting{false}, m_isClosing{false} {}
 
 bool TcpServer::listen(const boost::asio::ip::tcp &protocol, uint16_t port) {
   try {
@@ -28,9 +24,8 @@ bool TcpServer::listen(const boost::asio::ip::tcp &protocol, uint16_t port) {
     m_acceptor.bind({protocol, port});
     m_acceptor.listen(boost::asio::socket_base::max_connections);
   } catch (const std::exception &e) {
-    std::cerr << "TcpServer::Listen() caught exception: " +
-                     static_cast<std::string>(e.what())
-              << std::endl;
+    std::cerr << "TcpServer::listen() exception: " +
+                     static_cast<std::string>(e.what()) + ".\n";
     return false;
   }
   return true;
@@ -44,8 +39,7 @@ void TcpServer::startAcceptingConnections() {
 
 void TcpServer::send(int connectionId, const char *data, size_t size) {
   if (m_connections.count(connectionId) == 0) {
-    std::cerr << "TcpServer::send() found error: connectionId not found"
-              << std::endl;
+    std::cerr << "TcpServer::send() error: connection not found.\n";
     return;
   }
   m_connections.at(connectionId)->send(data, size);
@@ -59,25 +53,22 @@ void TcpServer::close() {
   }
   m_connections.clear();
   m_isClosing = false;
-  std::cout << "TCP Server was closed" << std::endl;
+  std::cout << "TCPServer disconnected.\n";
 }
 
 void TcpServer::doAccept() {
   m_isAccepting = true;
   m_acceptor.async_accept([this](const auto &error, auto socket) {
     if (error) {
-      std::cerr << "TcpServer::doAccept() found error: " + error.message()
-                << std::endl;
+      std::cerr << "TcpServer::doAccept() error: " + error.message() + ".\n";
       m_isAccepting = false;
       return;
     } else {
       auto connection{
           TcpConnection::create(std::move(socket), *this, m_connectionCount)};
       connection->startReading();
       m_connections.insert({m_connectionCount, std::move(connection)});
-      std::cout << "TCP Server accepted connection: " +
-                       std::to_string(m_connectionCount)
-                << std::endl;
+      std::cout << "TCPServer accepted connection.\n";
       m_observer.onConnectionAccepted(m_connectionCount);
       m_connectionCount++;
     }
@@ -94,9 +85,7 @@ void TcpServer::onConnectionClosed(int connectionId) {
     return;
   }
   if (m_connections.erase(connectionId) > 0) {
-    std::cout << "TCP Server removed connection: " +
-                     std::to_string(m_connectionCount)
-              << std::endl;
+    std::cout << "TCPServer removed connection.\n";
     m_observer.onConnectionClosed(connectionId);
   }
 }