Add serializable factory functionality for boxing package

CMakeLists.txt

@@ -99,7 +99,12 @@ set(SOURCE_FILES
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KVParser.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/io/kv/KVReader.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/SerializableFactory.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/boxing/SerializableJSONBooleanFactory.cpp)
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/boxing/SerializableJSONBooleanFactory.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/boxing/SerializableJSONDoubleFactory.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/boxing/SerializableJSONFloatFactory.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/boxing/SerializableJSONIntegerFactory.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/boxing/SerializableJSONLongFactory.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/source/ls_std/factory/serialization/boxing/SerializableJSONStringFactory.cpp)
 
 if (${LS_STD_BUILD_WITH_TESTS})
     set(TEST_FILES
@@ -161,6 +166,11 @@ if (${LS_STD_BUILD_WITH_TESTS})
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/io/kv/KVReaderTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/SerializableFactoryTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/boxing/SerializableJSONBooleanFactoryTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/boxing/SerializableJSONDoubleFactoryTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/boxing/SerializableJSONFloatFactoryTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/boxing/SerializableJSONIntegerFactoryTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/boxing/SerializableJSONLongFactoryTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/factory/serialization/boxing/SerializableJSONStringFactoryTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/classes/factory/SerializableTestFactory.cpp)
 endif ()
 

include/ls_std/factory/serialization/boxing/SerializableJSONDoubleFactory.hpp

@@ -0,0 +1,29 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-24
+ * Changed:         2021-04-24
+ *
+ * */
+
+#ifndef LS_STD_SERIALIZABLE_JSON_DOUBLE_FACTORY_HPP
+#define LS_STD_SERIALIZABLE_JSON_DOUBLE_FACTORY_HPP
+
+#include <ls_std/factory/IFactory.hpp>
+#include <memory>
+
+namespace ls_std
+{
+  class SerializableJSONDoubleFactory : public ls_std::Class, public ls_std::IFactory
+  {
+    public:
+
+      SerializableJSONDoubleFactory();
+      ~SerializableJSONDoubleFactory() override = default;
+
+      std::shared_ptr<ls_std::Class> build() override;
+  };
+}
+
+#endif

include/ls_std/factory/serialization/boxing/SerializableJSONFloatFactory.hpp

@@ -0,0 +1,29 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-24
+ * Changed:         2021-04-24
+ *
+ * */
+
+#ifndef LS_STD_SERIALIZABLE_JSON_FLOAT_FACTORY_HPP
+#define LS_STD_SERIALIZABLE_JSON_FLOAT_FACTORY_HPP
+
+#include <ls_std/factory/IFactory.hpp>
+#include <memory>
+
+namespace ls_std
+{
+  class SerializableJSONFloatFactory : public ls_std::Class, public ls_std::IFactory
+  {
+    public:
+
+      SerializableJSONFloatFactory();
+      ~SerializableJSONFloatFactory() override = default;
+
+      std::shared_ptr<ls_std::Class> build() override;
+  };
+}
+
+#endif

include/ls_std/factory/serialization/boxing/SerializableJSONIntegerFactory.hpp

@@ -0,0 +1,29 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-24
+ * Changed:         2021-04-24
+ *
+ * */
+
+#ifndef LS_STD_SERIALIZABLE_JSON_INTEGER_FACTORY_HPP
+#define LS_STD_SERIALIZABLE_JSON_INTEGER_FACTORY_HPP
+
+#include <ls_std/factory/IFactory.hpp>
+#include <memory>
+
+namespace ls_std
+{
+  class SerializableJSONIntegerFactory : public ls_std::Class, public ls_std::IFactory
+  {
+    public:
+
+      SerializableJSONIntegerFactory();
+      ~SerializableJSONIntegerFactory() override = default;
+
+      std::shared_ptr<ls_std::Class> build() override;
+  };
+}
+
+#endif

include/ls_std/factory/serialization/boxing/SerializableJSONLongFactory.hpp

@@ -0,0 +1,29 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-24
+ * Changed:         2021-04-24
+ *
+ * */
+
+#ifndef LS_STD_SERIALIZABLE_JSON_LONG_FACTORY_HPP
+#define LS_STD_SERIALIZABLE_JSON_LONG_FACTORY_HPP
+
+#include <ls_std/factory/IFactory.hpp>
+#include <memory>
+
+namespace ls_std
+{
+  class SerializableJSONLongFactory : public ls_std::Class, public ls_std::IFactory
+  {
+    public:
+
+      SerializableJSONLongFactory();
+      ~SerializableJSONLongFactory() override = default;
+
+      std::shared_ptr<ls_std::Class> build() override;
+  };
+}
+
+#endif

include/ls_std/factory/serialization/boxing/SerializableJSONStringFactory.hpp

@@ -0,0 +1,29 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-24
+ * Changed:         2021-04-24
+ *
+ * */
+
+#ifndef LS_STD_SERIALIZABLE_JSON_STRING_FACTORY_HPP
+#define LS_STD_SERIALIZABLE_JSON_STRING_FACTORY_HPP
+
+#include <ls_std/factory/IFactory.hpp>
+#include <memory>
+
+namespace ls_std
+{
+  class SerializableJSONStringFactory : public ls_std::Class, public ls_std::IFactory
+  {
+    public:
+
+      SerializableJSONStringFactory();
+      ~SerializableJSONStringFactory() override = default;
+
+      std::shared_ptr<ls_std::Class> build() override;
+  };
+}
+
+#endif

include/ls_std/ls_std.hpp

@@ -94,5 +94,10 @@
 #include "factory/IFactory.hpp"
 #include "factory/serialization/SerializableFactory.hpp"
 #include "factory/serialization/boxing/SerializableJSONBooleanFactory.hpp"
+#include "factory/serialization/boxing/SerializableJSONDoubleFactory.hpp"
+#include "factory/serialization/boxing/SerializableJSONFloatFactory.hpp"
+#include "factory/serialization/boxing/SerializableJSONIntegerFactory.hpp"
+#include "factory/serialization/boxing/SerializableJSONLongFactory.hpp"
+#include "factory/serialization/boxing/SerializableJSONStringFactory.hpp"
 
 #endif

source/ls_std/factory/serialization/SerializableFactory.cpp

@@ -9,7 +9,17 @@
 
 #include <ls_std/factory/serialization/SerializableFactory.hpp>
 #include <ls_std/boxing/Boolean.hpp>
+#include <ls_std/boxing/Double.hpp>
+#include <ls_std/boxing/Float.hpp>
+#include <ls_std/boxing/Integer.hpp>
+#include <ls_std/boxing/Long.hpp>
+#include <ls_std/boxing/String.hpp>
 #include <ls_std/factory/serialization/boxing/SerializableJSONBooleanFactory.hpp>
+#include <ls_std/factory/serialization/boxing/SerializableJSONDoubleFactory.hpp>
+#include <ls_std/factory/serialization/boxing/SerializableJSONFloatFactory.hpp>
+#include <ls_std/factory/serialization/boxing/SerializableJSONIntegerFactory.hpp>
+#include <ls_std/factory/serialization/boxing/SerializableJSONLongFactory.hpp>
+#include <ls_std/factory/serialization/boxing/SerializableJSONStringFactory.hpp>
 #include <ls_std/exception/IllegalArgumentException.hpp>
 #include <ls_std/exception/NullPointerException.hpp>
 
@@ -84,4 +94,9 @@ bool ls_std::SerializableFactory::_hasFactory(const std::string &_relatedObjectN
 void ls_std::SerializableFactory::_init()
 {
   this->factories.insert({ls_std::Boolean{}.getClassName(), std::make_shared<ls_std::SerializableJSONBooleanFactory>()});
+  this->factories.insert({ls_std::Double{}.getClassName(), std::make_shared<ls_std::SerializableJSONDoubleFactory>()});
+  this->factories.insert({ls_std::Float{}.getClassName(), std::make_shared<ls_std::SerializableJSONFloatFactory>()});
+  this->factories.insert({ls_std::Integer{}.getClassName(), std::make_shared<ls_std::SerializableJSONIntegerFactory>()});
+  this->factories.insert({ls_std::Long{}.getClassName(), std::make_shared<ls_std::SerializableJSONLongFactory>()});
+  this->factories.insert({ls_std::String{}.getClassName(), std::make_shared<ls_std::SerializableJSONStringFactory>()});
 }

source/ls_std/factory/serialization/boxing/SerializableJSONDoubleFactory.cpp

@@ -0,0 +1,24 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-24
+ * Changed:         2021-04-24
+ *
+ * */
+
+#include <ls_std/factory/serialization/boxing/SerializableJSONDoubleFactory.hpp>
+#include <ls_std/boxing/Double.hpp>
+#include <ls_std/serialization/boxing/SerializableJSONDouble.hpp>
+
+ls_std::SerializableJSONDoubleFactory::SerializableJSONDoubleFactory() : ls_std::Class("SerializableJSONDoubleFactory")
+{}
+
+std::shared_ptr<ls_std::Class> ls_std::SerializableJSONDoubleFactory::build()
+{
+  std::shared_ptr<ls_std::Double> value = std::make_shared<ls_std::Double>();
+  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJSONDouble>(value);
+  value->setSerializable(serializable);
+
+  return std::dynamic_pointer_cast<ls_std::Class>(value);
+}

source/ls_std/factory/serialization/boxing/SerializableJSONFloatFactory.cpp

@@ -0,0 +1,24 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-25
+ * Changed:         2021-04-25
+ *
+ * */
+
+#include <ls_std/factory/serialization/boxing/SerializableJSONFloatFactory.hpp>
+#include <ls_std/boxing/Float.hpp>
+#include <ls_std/serialization/boxing/SerializableJSONFloat.hpp>
+
+ls_std::SerializableJSONFloatFactory::SerializableJSONFloatFactory() : ls_std::Class("SerializableJSONFloatFactory")
+{}
+
+std::shared_ptr<ls_std::Class> ls_std::SerializableJSONFloatFactory::build()
+{
+  std::shared_ptr<ls_std::Float> value = std::make_shared<ls_std::Float>();
+  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJSONFloat>(value);
+  value->setSerializable(serializable);
+
+  return std::dynamic_pointer_cast<ls_std::Class>(value);
+}

source/ls_std/factory/serialization/boxing/SerializableJSONIntegerFactory.cpp

@@ -0,0 +1,24 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-25
+ * Changed:         2021-04-25
+ *
+ * */
+
+#include <ls_std/factory/serialization/boxing/SerializableJSONIntegerFactory.hpp>
+#include <ls_std/boxing/Integer.hpp>
+#include <ls_std/serialization/boxing/SerializableJSONInteger.hpp>
+
+ls_std::SerializableJSONIntegerFactory::SerializableJSONIntegerFactory() : ls_std::Class("SerializableJSONIntegerFactory")
+{}
+
+std::shared_ptr<ls_std::Class> ls_std::SerializableJSONIntegerFactory::build()
+{
+  std::shared_ptr<ls_std::Integer> value = std::make_shared<ls_std::Integer>();
+  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJSONInteger>(value);
+  value->setSerializable(serializable);
+
+  return std::dynamic_pointer_cast<ls_std::Class>(value);
+}

source/ls_std/factory/serialization/boxing/SerializableJSONLongFactory.cpp

@@ -0,0 +1,24 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-25
+ * Changed:         2021-04-25
+ *
+ * */
+
+#include <ls_std/factory/serialization/boxing/SerializableJSONLongFactory.hpp>
+#include <ls_std/boxing/Long.hpp>
+#include <ls_std/serialization/boxing/SerializableJSONLong.hpp>
+
+ls_std::SerializableJSONLongFactory::SerializableJSONLongFactory() : ls_std::Class("SerializableJSONLongFactory")
+{}
+
+std::shared_ptr<ls_std::Class> ls_std::SerializableJSONLongFactory::build()
+{
+  std::shared_ptr<ls_std::Long> value = std::make_shared<ls_std::Long>();
+  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJSONLong>(value);
+  value->setSerializable(serializable);
+
+  return std::dynamic_pointer_cast<ls_std::Class>(value);
+}

source/ls_std/factory/serialization/boxing/SerializableJSONStringFactory.cpp

@@ -0,0 +1,24 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-25
+ * Changed:         2021-04-25
+ *
+ * */
+
+#include <ls_std/factory/serialization/boxing/SerializableJSONStringFactory.hpp>
+#include <ls_std/boxing/String.hpp>
+#include <ls_std/serialization/boxing/SerializableJSONString.hpp>
+
+ls_std::SerializableJSONStringFactory::SerializableJSONStringFactory() : ls_std::Class("SerializableJSONStringFactory")
+{}
+
+std::shared_ptr<ls_std::Class> ls_std::SerializableJSONStringFactory::build()
+{
+  std::shared_ptr<ls_std::String> value = std::make_shared<ls_std::String>();
+  std::shared_ptr<ls_std::ISerializable> serializable = std::make_shared<ls_std::SerializableJSONString>(value);
+  value->setSerializable(serializable);
+
+  return std::dynamic_pointer_cast<ls_std::Class>(value);
+}

test/cases/factory/serialization/SerializableFactoryTest.cpp

@@ -103,10 +103,15 @@ namespace
     ASSERT_TRUE(serializableFactory.clear());
   }
 
-  TEST_F(SerializableFactoryTest, hasFactory)
+  TEST_F(SerializableFactoryTest, hasFactory_ofBoxingPackage)
   {
     ls_std::SerializableFactory serializableFactory{};
     ASSERT_TRUE(serializableFactory.hasFactory(ls_std::Boolean{}.getClassName()));
+    ASSERT_TRUE(serializableFactory.hasFactory(ls_std::Double{}.getClassName()));
+    ASSERT_TRUE(serializableFactory.hasFactory(ls_std::Float{}.getClassName()));
+    ASSERT_TRUE(serializableFactory.hasFactory(ls_std::Integer{}.getClassName()));
+    ASSERT_TRUE(serializableFactory.hasFactory(ls_std::Long{}.getClassName()));
+    ASSERT_TRUE(serializableFactory.hasFactory(ls_std::String{}.getClassName()));
   }
 
   TEST_F(SerializableFactoryTest, hasFactory_factoryNotAvailable)

test/cases/factory/serialization/boxing/SerializableJSONBooleanFactoryTest.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2021-04-23
- * Changed:         2021-04-23
+ * Changed:         2021-04-25
  *
  * */
 
@@ -30,5 +30,6 @@ namespace
   {
     std::shared_ptr<ls_std::Boolean> value = std::dynamic_pointer_cast<ls_std::Boolean>(ls_std::SerializableJSONBooleanFactory{}.build());
     ASSERT_TRUE(value != nullptr);
+    ASSERT_STREQ("Boolean", value->getClassName().c_str());
   }
 }

test/cases/factory/serialization/boxing/SerializableJSONDoubleFactoryTest.cpp

@@ -0,0 +1,35 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-24
+ * Changed:         2021-04-24
+ *
+ * */
+
+#include <gtest/gtest.h>
+#include <ls_std/ls_std.hpp>
+
+namespace
+{
+  class SerializableJSONDoubleFactoryTest : public ::testing::Test
+  {
+    protected:
+
+      SerializableJSONDoubleFactoryTest() = default;
+      ~SerializableJSONDoubleFactoryTest() override = default;
+
+      void SetUp() override
+      {}
+
+      void TearDown() override
+      {}
+  };
+
+  TEST_F(SerializableJSONDoubleFactoryTest, build)
+  {
+    std::shared_ptr<ls_std::Double> value = std::dynamic_pointer_cast<ls_std::Double>(ls_std::SerializableJSONDoubleFactory{}.build());
+    ASSERT_TRUE(value != nullptr);
+    ASSERT_STREQ("Double", value->getClassName().c_str());
+  }
+}

test/cases/factory/serialization/boxing/SerializableJSONFloatFactoryTest.cpp

@@ -0,0 +1,35 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-25
+ * Changed:         2021-04-25
+ *
+ * */
+
+#include <gtest/gtest.h>
+#include <ls_std/ls_std.hpp>
+
+namespace
+{
+  class SerializableJSONFloatFactoryTest : public ::testing::Test
+  {
+    protected:
+
+      SerializableJSONFloatFactoryTest() = default;
+      ~SerializableJSONFloatFactoryTest() override = default;
+
+      void SetUp() override
+      {}
+
+      void TearDown() override
+      {}
+  };
+
+  TEST_F(SerializableJSONFloatFactoryTest, build)
+  {
+    std::shared_ptr<ls_std::Float> value = std::dynamic_pointer_cast<ls_std::Float>(ls_std::SerializableJSONFloatFactory{}.build());
+    ASSERT_TRUE(value != nullptr);
+    ASSERT_STREQ("Float", value->getClassName().c_str());
+  }
+}

test/cases/factory/serialization/boxing/SerializableJSONIntegerFactoryTest.cpp

@@ -0,0 +1,35 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-25
+ * Changed:         2021-04-25
+ *
+ * */
+
+#include <gtest/gtest.h>
+#include <ls_std/ls_std.hpp>
+
+namespace
+{
+  class SerializableJSONIntegerFactoryTest : public ::testing::Test
+  {
+    protected:
+
+      SerializableJSONIntegerFactoryTest() = default;
+      ~SerializableJSONIntegerFactoryTest() override = default;
+
+      void SetUp() override
+      {}
+
+      void TearDown() override
+      {}
+  };
+
+  TEST_F(SerializableJSONIntegerFactoryTest, build)
+  {
+    std::shared_ptr<ls_std::Integer> value = std::dynamic_pointer_cast<ls_std::Integer>(ls_std::SerializableJSONIntegerFactory{}.build());
+    ASSERT_TRUE(value != nullptr);
+    ASSERT_STREQ("Integer", value->getClassName().c_str());
+  }
+}

test/cases/factory/serialization/boxing/SerializableJSONLongFactoryTest.cpp

@@ -0,0 +1,35 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-25
+ * Changed:         2021-04-25
+ *
+ * */
+
+#include <gtest/gtest.h>
+#include <ls_std/ls_std.hpp>
+
+namespace
+{
+  class SerializableJSONLongFactoryTest : public ::testing::Test
+  {
+    protected:
+
+      SerializableJSONLongFactoryTest() = default;
+      ~SerializableJSONLongFactoryTest() override = default;
+
+      void SetUp() override
+      {}
+
+      void TearDown() override
+      {}
+  };
+
+  TEST_F(SerializableJSONLongFactoryTest, build)
+  {
+    std::shared_ptr<ls_std::Long> value = std::dynamic_pointer_cast<ls_std::Long>(ls_std::SerializableJSONLongFactory{}.build());
+    ASSERT_TRUE(value != nullptr);
+    ASSERT_STREQ("Long", value->getClassName().c_str());
+  }
+}

test/cases/factory/serialization/boxing/SerializableJSONStringFactoryTest.cpp

@@ -0,0 +1,35 @@
+/*
+ * Author:          Patrick-Christopher Mattulat
+ * Company:         Lynar Studios
+ * E-Mail:          webmaster@lynarstudios.com
+ * Created:         2021-04-25
+ * Changed:         2021-04-25
+ *
+ * */
+
+#include <gtest/gtest.h>
+#include <ls_std/ls_std.hpp>
+
+namespace
+{
+  class SerializableJSONStringFactoryTest : public ::testing::Test
+  {
+    protected:
+
+      SerializableJSONStringFactoryTest() = default;
+      ~SerializableJSONStringFactoryTest() override = default;
+
+      void SetUp() override
+      {}
+
+      void TearDown() override
+      {}
+  };
+
+  TEST_F(SerializableJSONStringFactoryTest, build)
+  {
+    std::shared_ptr<ls_std::String> value = std::dynamic_pointer_cast<ls_std::String>(ls_std::SerializableJSONStringFactory{}.build());
+    ASSERT_TRUE(value != nullptr);
+    ASSERT_STREQ("String", value->getClassName().c_str());
+  }
+}