Add ProtocolFamilyMapper class

This class maps the protocol family type to an OS specific protocol family.

CMakeLists.txt

@@ -180,6 +180,7 @@ set(SOURCE_FILES_IO
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/StorableFile.cpp)
 
 set(SOURCE_FILES_NETWORK
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/network/core/ProtocolFamilyMapper.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/network/socket/Socket.cpp)
 
 set(SOURCE_FILES_TIME
@@ -259,6 +260,7 @@ if (${LS_STD_BUILD_WITH_TESTS})
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/io/xml/XmlParserTestWrapper.cpp)
 
     set(TEST_FILES_NETWORK
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/network/core/ProtocolFamilyMapperTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/network/socket/SocketTest.cpp)
 
     set(TEST_FILES_SERIALIZATION

include/ls_std/ls_std_network.hpp

@@ -10,8 +10,12 @@
 #ifndef LS_STD_LS_STD_NETWORK_HPP
 #define LS_STD_LS_STD_NETWORK_HPP
 
+#include <ls_std/network/core/ProtocolFamily.hpp>
+#include <ls_std/network/core/ProtocolFamilyMapper.hpp>
+#include <ls_std/network/core/ProtocolFamilyType.hpp>
 #include <ls_std/network/core/ProtocolType.hpp>
 #include <ls_std/network/socket/Socket.hpp>
+#include <ls_std/network/socket/SocketAddress.hpp>
 #include <ls_std/network/socket/SocketParameter.hpp>
 
 #endif

include/ls_std/network/core/ProtocolFamily.hpp

@@ -0,0 +1,21 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-11-16
+ * Changed:         2022-11-16
+ *
+ * */
+
+#ifndef LS_STD_PROTOCOL_FAMILY_HPP
+#define LS_STD_PROTOCOL_FAMILY_HPP
+
+namespace ls::std::network
+{
+  struct ProtocolFamily
+  {
+    int unixDomain{};
+  };
+}
+
+#endif

include/ls_std/network/core/ProtocolFamilyMapper.hpp

@@ -0,0 +1,34 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-11-16
+ * Changed:         2022-11-16
+ *
+ * */
+
+#ifndef LS_STD_PROTOCOL_FAMILY_MAPPER_HPP
+#define LS_STD_PROTOCOL_FAMILY_MAPPER_HPP
+
+#include <ls_std/core/Class.hpp>
+#include <ls_std/network/core/ProtocolFamily.hpp>
+#include <ls_std/network/core/ProtocolFamilyType.hpp>
+
+namespace ls::std::network
+{
+  class ProtocolFamilyMapper : public ls::std::core::Class
+  {
+    public:
+
+      ProtocolFamilyMapper();
+      ~ProtocolFamilyMapper() override = default;
+
+      [[nodiscard]] static ls::std::network::ProtocolFamily from(const ls::std::network::ProtocolFamilyType& _protocolFamilyType);
+
+    private:
+
+      [[nodiscard]] static ls::std::network::ProtocolFamily _toUnixProtocolFamily(const ls::std::network::ProtocolFamilyType& _protocolFamilyType);
+  };
+}
+
+#endif

include/ls_std/network/core/ProtocolFamilyType.hpp

@@ -0,0 +1,22 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-11-16
+ * Changed:         2022-11-16
+ *
+ * */
+
+#ifndef LS_STD_PROTOCOL_FAMILY_TYPE_HPP
+#define LS_STD_PROTOCOL_FAMILY_TYPE_HPP
+
+namespace ls::std::network
+{
+  enum ProtocolFamilyType
+  {
+    PROTOCOL_FAMILY_TYPE_NOT_INITIALIZED = 0,
+    PROTOCOL_FAMILY_TYPE_IPV4
+  };
+}
+
+#endif

source/ls_std/network/core/ProtocolFamilyMapper.cpp

@@ -0,0 +1,45 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2022-11-16
+ * Changed:         2022-11-16
+ *
+ * */
+
+#include <ls_std/network/core/ProtocolFamilyMapper.hpp>
+#include <ls_std/core/exception/IllegalArgumentException.hpp>
+#if defined(unix) || defined(__APPLE__)
+#include <sys/socket.h>
+#endif
+
+ls::std::network::ProtocolFamilyMapper::ProtocolFamilyMapper() : ls::std::core::Class("ProtocolFamilyMapper")
+{}
+
+ls::std::network::ProtocolFamily ls::std::network::ProtocolFamilyMapper::from(const ls::std::network::ProtocolFamilyType &_protocolFamilyType)
+{
+  #if defined(unix) || defined(__APPLE__)
+  return ls::std::network::ProtocolFamilyMapper::_toUnixProtocolFamily(_protocolFamilyType);
+  #endif
+}
+
+#if defined(unix) || defined(__APPLE__)
+ls::std::network::ProtocolFamily ls::std::network::ProtocolFamilyMapper::_toUnixProtocolFamily(const ls::std::network::ProtocolFamilyType &_protocolFamilyType)
+{
+  ls::std::network::ProtocolFamily protocolFamily{};
+
+  switch(_protocolFamilyType)
+  {
+    case ls::std::network::ProtocolFamilyType::PROTOCOL_FAMILY_TYPE_IPV4:
+    {
+      protocolFamily.unixDomain = AF_INET;
+    } break;
+    case ls::std::network::ProtocolFamilyType::PROTOCOL_FAMILY_TYPE_NOT_INITIALIZED:
+    {
+      throw ls::std::core::IllegalArgumentException{};
+    }
+  }
+
+  return protocolFamily;
+}
+#endif

test/cases/network/core/ProtocolFamilyMapperTest.cpp

@@ -0,0 +1,63 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2020-11-16
+ * Changed:         2022-11-16
+ *
+ * */
+
+#include <gtest/gtest.h>
+#include <ls_std/ls_std_network.hpp>
+#if defined(unix) || defined(__APPLE__)
+#include <sys/socket.h>
+#endif
+#include <ls_std/ls_std_core.hpp>
+
+using namespace ls::std::network;
+using namespace ls::std::core;
+
+namespace
+{
+  class ProtocolFamilyMapperTest : public ::testing::Test
+  {
+    protected:
+
+      ProtocolFamilyMapperTest() = default;
+      ~ProtocolFamilyMapperTest() override = default;
+
+      void SetUp() override
+      {}
+
+      void TearDown() override
+      {}
+  };
+
+  TEST_F(ProtocolFamilyMapperTest, getClassName)
+  {
+    ASSERT_STREQ("ProtocolFamilyMapper", ProtocolFamilyMapper{}.getClassName().c_str());
+  }
+
+  TEST_F(ProtocolFamilyMapperTest, from)
+  {
+    ProtocolFamily protocolFamily = ProtocolFamilyMapper::from(ProtocolFamilyType::PROTOCOL_FAMILY_TYPE_IPV4);
+
+    #if defined(unix) || defined(__APPLE__)
+    ASSERT_EQ(AF_INET, protocolFamily.unixDomain);
+    #endif
+  }
+
+  TEST_F(ProtocolFamilyMapperTest, from_invalid_protocol_type)
+  {
+    EXPECT_THROW({
+                   try
+                   {
+                     ProtocolFamily protocolFamily = ProtocolFamilyMapper::from(ProtocolFamilyType::PROTOCOL_FAMILY_TYPE_NOT_INITIALIZED);
+                   }
+                   catch (const IllegalArgumentException &_exception)
+                   {
+                     throw;
+                   }
+                 }, IllegalArgumentException);
+  }
+}