Add write method to Socket class

CMakeLists.txt

@@ -194,9 +194,11 @@ if(${CMAKE_CXX_COMPILER_ID} STREQUAL GNU OR
         ${CMAKE_CXX_COMPILER_ID} STREQUAL AppleClang)
     set(SOURCE_FILES_NETWORK
             ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/common/api/io/PosixReader.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/common/api/io/PosixWriter.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/common/api/socket/PosixSocket.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/common/interface/IPosixReader.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/common/interface/IPosixSocket.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/common/interface/IPosixWriter.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/network/core/ProtocolFamilyMapper.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/network/core/ProtocolMapper.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/network/socket/Socket.cpp

include/ls_std/common/api/io/PosixWriter.hpp

@@ -0,0 +1,28 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-12-25
+ * Changed:         2022-12-25
+ *
+ * */
+
+#ifndef LS_STD_POSIX_WRITER_HPP
+#define LS_STD_POSIX_WRITER_HPP
+
+#include <ls_std/common/interface/IPosixWriter.hpp>
+
+namespace ls::std::common::api
+{
+  class PosixWriter : public ls::std::common::interface_type::IPosixWriter
+  {
+    public:
+
+      PosixWriter();
+      ~PosixWriter() override;
+
+      size_t write(int _unixFileDescriptor, void* _buffer, size_t _size) override;
+  };
+}
+
+#endif

include/ls_std/common/interface/IPosixWriter.hpp

@@ -0,0 +1,28 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-12-25
+ * Changed:         2022-12-25
+ *
+ * */
+
+#ifndef LS_STD_I_POSIX_WRITER_HPP
+#define LS_STD_I_POSIX_WRITER_HPP
+
+#include <unistd.h>
+
+namespace ls::std::common::interface_type
+{
+  class IPosixWriter
+  {
+    public:
+
+      IPosixWriter();
+      virtual ~IPosixWriter();
+
+      virtual size_t write(int _unixFileDescriptor, void* _buffer, size_t _size) = 0;
+  };
+}
+
+#endif

include/ls_std/ls_std_common.hpp

@@ -12,10 +12,12 @@
 
 #if defined(unix) || defined(__APPLE__)
 #include <ls_std/common/api/io/PosixReader.hpp>
+#include <ls_std/common/api/io/PosixWriter.hpp>
 #include <ls_std/common/api/socket/PosixSocket.hpp>
 
 #include <ls_std/common/interface/IPosixReader.hpp>
 #include <ls_std/common/interface/IPosixSocket.hpp>
+#include <ls_std/common/interface/IPosixWriter.hpp>
 #endif
 
 #endif

include/ls_std/network/socket/Socket.hpp

@@ -17,10 +17,11 @@
 #include <memory>
 #include <ls_std/core/types/Types.hpp>
 #include <ls_std/core/interface/IReader.hpp>
+#include <ls_std/core/interface/IWriter.hpp>
 
 namespace ls::std::network
 {
-  class LS_STD_DYNAMIC_GOAL Socket : public ls::std::core::Class, public ls::std::core::interface_type::IReader
+  class LS_STD_DYNAMIC_GOAL Socket : public ls::std::core::Class, public ls::std::core::interface_type::IReader, public ls::std::core::interface_type::IWriter
   {
     public:
 
@@ -30,6 +31,7 @@ namespace ls::std::network
       // implementation
 
       [[nodiscard]] ls::std::core::type::byte_field read() override;
+      [[nodiscard]] bool write(const ls::std::core::type::byte_field &_data) override;
 
       // other functionalities
 
@@ -68,6 +70,11 @@ namespace ls::std::network
       ls::std::core::type::byte_field _readUnix();
       void _setPosixReaderApi();
       void _setPosixSocketApi();
+      void _setPosixWriterApi();
+      #endif
+      bool _write(const ls::std::core::type::byte_field &_data);
+      #if defined(unix) || defined(__APPLE__)
+      bool _writeUnix(const ls::std::core::type::byte_field &_data);
       #endif
   };
 }

include/ls_std/network/socket/SocketParameter.hpp

@@ -13,6 +13,7 @@
 #include <ls_std/network/core/ProtocolFamilyType.hpp>
 #include <ls_std/common/interface/IPosixSocket.hpp>
 #include <ls_std/common/interface/IPosixReader.hpp>
+#include <ls_std/common/interface/IPosixWriter.hpp>
 #include "SocketAddress.hpp"
 #include <memory>
 
@@ -22,6 +23,7 @@ namespace ls::std::network
   {
     ::std::shared_ptr<ls::std::common::interface_type::IPosixReader> posixReader{};
     ::std::shared_ptr<ls::std::common::interface_type::IPosixSocket> posixSocket{};
+    ::std::shared_ptr<ls::std::common::interface_type::IPosixWriter> posixWriter{};
     ls::std::network::ProtocolFamilyType protocolFamilyType{};
     int queueSize{};
     size_t readBufferSize{};

source/ls_std/common/api/io/PosixWriter.cpp

@@ -0,0 +1,21 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-12-25
+ * Changed:         2022-12-25
+ *
+ * */
+
+#include <ls_std/common/api/io/PosixWriter.hpp>
+
+ls::std::common::api::PosixWriter::PosixWriter()
+= default;
+
+ls::std::common::api::PosixWriter::~PosixWriter()
+= default;
+
+size_t ls::std::common::api::PosixWriter::write(int _unixFileDescriptor, void *_buffer, size_t _size)
+{
+  return ::write(_unixFileDescriptor, _buffer, _size);
+}

source/ls_std/common/interface/IPosixWriter.cpp

@@ -0,0 +1,16 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-12-25
+ * Changed:         2022-12-25
+ *
+ * */
+
+#include <ls_std/common/interface/IPosixWriter.hpp>
+
+ls::std::common::interface_type::IPosixWriter::IPosixWriter()
+= default;
+
+ls::std::common::interface_type::IPosixWriter::~IPosixWriter()
+= default;

source/ls_std/network/socket/Socket.cpp

@@ -14,6 +14,7 @@
 #include <ls_std/network/socket/SocketAddressMapper.hpp>
 #include <ls_std/common/api/socket/PosixSocket.hpp>
 #include <ls_std/common/api/io/PosixReader.hpp>
+#include <ls_std/common/api/io/PosixWriter.hpp>
 #include <ls_std/core/exception/WrongProtocolException.hpp>
 #include <ls_std/core/exception/IllegalArgumentException.hpp>
 #include <ls_std/core/exception/FileOperationException.hpp>
@@ -44,6 +45,11 @@ ls::std::core::type::byte_field ls::std::network::Socket::read()
   return this->_read();
 }
 
+bool ls::std::network::Socket::write(const ls::std::core::type::byte_field &_data)
+{
+  return this->_write(_data);
+}
+
 bool ls::std::network::Socket::accept()
 {
   if (this->parameter.socketAddress.protocolType != PROTOCOL_TYPE_TCP)
@@ -151,6 +157,7 @@ bool ls::std::network::Socket::_initUnix()
 {
   this->_setPosixReaderApi();
   this->_setPosixSocketApi();
+  this->_setPosixWriterApi();
   ls::std::network::ConvertedProtocolFamily convertedProtocolFamily = ls::std::network::ProtocolFamilyMapper::from(this->parameter.protocolFamilyType);
   ls::std::network::Protocol protocol = ls::std::network::ProtocolMapper::from(this->parameter.socketAddress.protocolType);
 
@@ -177,7 +184,7 @@ ls::std::core::type::byte_field ls::std::network::Socket::_readUnix()
 
   if (size == -1)
   {
-    throw ls::std::core::FileOperationException{};
+    throw ls::std::core::FileOperationException{}; // TODO: write test
   }
 
   return ls::std::core::type::byte_field{this->readBuffer, size};
@@ -198,4 +205,39 @@ void ls::std::network::Socket::_setPosixSocketApi()
     this->parameter.posixSocket = ::std::make_shared<ls::std::common::api::PosixSocket>();
   }
 }
+
+void ls::std::network::Socket::_setPosixWriterApi()
+{
+  if (this->parameter.posixWriter == nullptr)
+  {
+    this->parameter.posixWriter = ::std::make_shared<ls::std::common::api::PosixWriter>();
+  }
+}
+#endif
+
+bool ls::std::network::Socket::_write(const ls::std::core::type::byte_field &_data)
+{
+  #if defined(unix) || defined(__APPLE__)
+  return this->_writeUnix(_data);
+  #endif
+}
+
+#if defined(unix) || defined(__APPLE__)
+bool ls::std::network::Socket::_writeUnix(const ls::std::core::type::byte_field &_data)
+{
+  bool written{};
+
+  if (!_data.empty())
+  {
+    size_t size = _data.size() + 1;
+    char* buffer = new char[size];
+    ::std::strcpy(buffer, _data.c_str());
+
+    written = this->parameter.posixWriter->write(this->unixDescriptor, buffer, size) != -1;
+
+    delete[] buffer;
+  }
+
+  return written;
+}
 #endif

test/cases/network/socket/SocketTest.cpp

@@ -11,6 +11,7 @@
 #include <ls_std/ls_std_network.hpp>
 #include <ls_std/ls_std_core.hpp>
 #include <ls_std_core_test.hpp>
+#include <ls_std_common_test.hpp>
 
 using namespace ls::std::network;
 using namespace ::testing;
@@ -18,6 +19,7 @@ using namespace ::std;
 using namespace ls::std::core;
 using namespace ls::std::core::type;
 using namespace ls_std_core_test;
+using namespace ls_std_common_test;
 
 namespace
 {
@@ -102,6 +104,27 @@ namespace
                  }, IllegalArgumentException);
   }
 
+  TEST_F(SocketTest, write)
+  {
+    SocketParameter parameter = generateSocketParameter();
+
+    #if defined(unix) || defined(__APPLE__)
+    shared_ptr<MockPosixSocket> mockSocket = make_shared<MockPosixSocket>();
+    shared_ptr<MockPosixWriter> mockWriter = make_shared<MockPosixWriter>();
+    parameter.posixSocket = mockSocket;
+    parameter.posixWriter = mockWriter;
+
+    EXPECT_CALL(*mockSocket, create(_, _, _)).Times(AtLeast(1));
+    ON_CALL(*mockSocket, create(_, _, _)).WillByDefault(Return(0));
+    EXPECT_CALL(*mockWriter, write(_, _, _)).Times(AtLeast(1));
+    ON_CALL(*mockWriter, write(_, _, _)).WillByDefault(Return(0));
+    #endif
+
+    Socket socket{parameter};
+
+    ASSERT_TRUE(socket.write("Hello Server!"));
+  }
+
   TEST_F(SocketTest, accept)
   {
     SocketParameter parameter = generateSocketParameter();

test/classes/common/api/io/MockPosixWriter.hpp

@@ -0,0 +1,29 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-12-25
+ * Changed:         2022-12-25
+ *
+ * */
+
+#ifndef LS_STD_MOCK_POSIX_WRITER_HPP
+#define LS_STD_MOCK_POSIX_WRITER_HPP
+
+#include <ls_std/ls_std_common.hpp>
+#include <gmock/gmock.h>
+
+namespace ls_std_common_test
+{
+  class MockPosixWriter : public ls::std::common::interface_type::IPosixWriter
+  {
+    public:
+
+      MockPosixWriter() = default;
+      ~MockPosixWriter() override = default;
+
+      MOCK_METHOD(size_t, write, (int _unixFileDescriptor, void* _buffer, size_t _size), (override));
+  };
+}
+
+#endif

test/classes/core/api/io/MockPosixReader.hpp

@@ -15,7 +15,7 @@
 
 namespace ls_std_core_test
 {
-  class MockPosixReader : public ls::std::common::interface_type::IPosixReader
+  class MockPosixReader : public ls::std::common::interface_type::IPosixReader // TODO: move to "common" module
   {
     public:
 

test/classes/core/api/socket/MockPosixSocket.hpp

@@ -15,7 +15,7 @@
 
 namespace ls_std_core_test
 {
-  class MockPosixSocket : public ls::std::common::interface_type::IPosixSocket
+  class MockPosixSocket : public ls::std::common::interface_type::IPosixSocket // TODO: move to "common" module
   {
     public:
 

test/ls_std_common_test.hpp

@@ -0,0 +1,15 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-12-25
+ * Changed:         2022-12-25
+ *
+ * */
+
+#ifndef LS_STD_LS_STD_COMMON_TEST_HPP
+#define LS_STD_LS_STD_COMMON_TEST_HPP
+
+#include <classes/common/api/io/MockPosixWriter.hpp>
+
+#endif