Remove raw void pointer usage in JNI classes

CMakeLists.txt

@@ -309,6 +309,8 @@ if (${LS_STD_BUILD_WITH_TESTS})
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/evaluator/IndexOutOfBoundsEvaluatorTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/evaluator/NullPointerArgumentEvaluatorTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/evaluator/NullPointerEvaluatorTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/evaluator/RawNullPointerArgumentEvaluatorTest.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/evaluator/RawNullPointerEvaluatorTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/exception/EventNotHandledExceptionTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/exception/EventNotSubscribedExceptionTest.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cases/core/exception/ExceptionMessageTest.cpp

include/ls-std/core/evaluator/NullPointerArgumentEvaluator.hpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-04-07
+* Changed:         2023-05-23
 *
 * */
 
@@ -11,6 +11,7 @@
 #define LS_STD_NULL_POINTER_ARGUMENT_EVALUATOR_HPP
 
 #include <ls-std/core/interface/IEvaluator.hpp>
+#include <ls-std/core/type/RawPointer.hpp>
 #include <ls-std/os/dynamic-goal.hpp>
 #include <memory>
 #include <string>
@@ -21,8 +22,6 @@ namespace ls::std::core
   {
     public:
 
-      explicit NullPointerArgumentEvaluator(const void *_rawArgument);
-      explicit NullPointerArgumentEvaluator(const void *_rawArgument, ::std::string _message);
       explicit NullPointerArgumentEvaluator(const ::std::shared_ptr<void> &_argument);
       explicit NullPointerArgumentEvaluator(const ::std::shared_ptr<void> &_argument, ::std::string _message);
       ~NullPointerArgumentEvaluator() noexcept override;

include/ls-std/core/evaluator/NullPointerEvaluator.hpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-04-04
+* Changed:         2023-05-24
 *
 * */
 
@@ -21,8 +21,6 @@ namespace ls::std::core
   {
     public:
 
-      explicit NullPointerEvaluator(const void *_rawArgument);
-      explicit NullPointerEvaluator(const void *_rawArgument, ::std::string _message);
       explicit NullPointerEvaluator(const ::std::shared_ptr<void> &_argument);
       explicit NullPointerEvaluator(const ::std::shared_ptr<void> &_argument, ::std::string _message);
       ~NullPointerEvaluator() noexcept override;

include/ls-std/core/evaluator/RawNullPointerArgumentEvaluator.hpp

@@ -0,0 +1,53 @@
+/*
+* Author:          Patrick-Christopher Mattulat
+* Company:         Lynar Studios
+* E-Mail:          webmaster@lynarstudios.com
+* Created:         2023-05-23
+* Changed:         2023-05-23
+*
+* */
+
+#ifndef LS_STD_RAW_NULL_POINTER_ARGUMENT_EVALUATOR_HPP
+#define LS_STD_RAW_NULL_POINTER_ARGUMENT_EVALUATOR_HPP
+
+#include <ls-std/core/exception/IllegalArgumentException.hpp>
+#include <ls-std/core/interface/IEvaluator.hpp>
+#include <ls-std/core/type/RawPointer.hpp>
+#include <string>
+
+namespace ls::std::core
+{
+  template<typename T>
+  class RawNullPointerArgumentEvaluator : public ls::std::core::interface_type::IEvaluator
+  {
+    public:
+
+      explicit RawNullPointerArgumentEvaluator(const ls::std::core::type::RawPointer<T> &_argument) : argument(_argument)
+      {}
+      explicit RawNullPointerArgumentEvaluator(const ls::std::core::type::RawPointer<T> &_argument, ::std::string _message) : argument(_argument), message(::std::move(_message))
+      {}
+      ~RawNullPointerArgumentEvaluator() noexcept override = default;
+
+      void evaluate() override
+      {
+        if (this->argument.get() == nullptr)
+        {
+          if (this->message.empty())
+          {
+            throw ls::std::core::IllegalArgumentException{"passed argument is null!"};
+          }
+          else
+          {
+            throw ls::std::core::IllegalArgumentException{this->message};
+          }
+        }
+      }
+
+    private:
+
+      ls::std::core::type::RawPointer<T> argument{};
+      ::std::string message{};
+  };
+}
+
+#endif

include/ls-std/core/evaluator/RawNullPointerEvaluator.hpp

@@ -0,0 +1,53 @@
+/*
+* Author:          Patrick-Christopher Mattulat
+* Company:         Lynar Studios
+* E-Mail:          webmaster@lynarstudios.com
+* Created:         2023-05-24
+* Changed:         2023-05-24
+*
+* */
+
+#ifndef LS_STD_RAW_NULL_POINTER_EVALUATOR_HPP
+#define LS_STD_RAW_NULL_POINTER_EVALUATOR_HPP
+
+#include <ls-std/core/exception/NullPointerException.hpp>
+#include <ls-std/core/interface/IEvaluator.hpp>
+#include <ls-std/core/type/RawPointer.hpp>
+#include <string>
+
+namespace ls::std::core
+{
+  template<typename T>
+  class RawNullPointerEvaluator : public ls::std::core::interface_type::IEvaluator
+  {
+    public:
+
+      explicit RawNullPointerEvaluator(const ls::std::core::type::RawPointer<T> &_argument) : argument(_argument)
+      {}
+      RawNullPointerEvaluator(const ls::std::core::type::RawPointer<T> &_argument, ::std::string _message) : argument(_argument), message(::std::move(_message))
+      {}
+      ~RawNullPointerEvaluator() noexcept override = default;
+
+      void evaluate() override
+      {
+        if (this->argument.get() == nullptr)
+        {
+          if (this->message.empty())
+          {
+            throw ls::std::core::NullPointerException{"reference in use is null!"};
+          }
+          else
+          {
+            throw ls::std::core::NullPointerException{this->message};
+          }
+        }
+      }
+
+    private:
+
+      ls::std::core::type::RawPointer<T> argument{};
+      ::std::string message{};
+  };
+}
+
+#endif

include/ls-std/core/type/RawPointer.hpp

@@ -0,0 +1,35 @@
+/*
+* Author:          Patrick-Christopher Mattulat
+* Company:         Lynar Studios
+* E-Mail:          webmaster@lynarstudios.com
+* Created:         2023-05-23
+* Changed:         2023-05-23
+*
+* */
+
+#ifndef LS_STD_RAW_POINTER_HPP
+#define LS_STD_RAW_POINTER_HPP
+
+namespace ls::std::core::type
+{
+  template<typename T>
+  class RawPointer
+  {
+    public:
+
+      explicit RawPointer(T *_pointer) : pointer(_pointer)
+      {}
+      ~RawPointer() = default;
+
+      [[nodiscard]] T *get() const
+      {
+        return this->pointer;
+      }
+
+    private:
+
+      T *pointer{};
+  };
+}
+
+#endif

include/ls-std/ls-std-core.hpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2022-05-13
- * Changed:         2023-03-27
+ * Changed:         2023-05-24
  *
  * */
 
@@ -14,6 +14,8 @@
 #include <ls-std/core/evaluator/IndexOutOfBoundsEvaluator.hpp>
 #include <ls-std/core/evaluator/NullPointerArgumentEvaluator.hpp>
 #include <ls-std/core/evaluator/NullPointerEvaluator.hpp>
+#include <ls-std/core/evaluator/RawNullPointerArgumentEvaluator.hpp>
+#include <ls-std/core/evaluator/RawNullPointerEvaluator.hpp>
 
 #include <ls-std/core/exception/EventNotHandledException.hpp>
 #include <ls-std/core/exception/EventNotSubscribedException.hpp>
@@ -39,6 +41,7 @@
 #include <ls-std/core/interface/IWriter.hpp>
 
 #include <ls-std/core/type/EventTypes.hpp>
+#include <ls-std/core/type/RawPointer.hpp>
 #include <ls-std/core/type/Types.hpp>
 
 #include <ls-std/core/Class.hpp>

source/ls-std/core/evaluator/NullPointerArgumentEvaluator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-04-07
+* Changed:         2023-05-23
 *
 * */
 
@@ -17,23 +17,6 @@ using std::move;
 using std::shared_ptr;
 using std::string;
 
-NullPointerArgumentEvaluator::NullPointerArgumentEvaluator(const void *_rawArgument)
-{
-  shared_ptr<void> value{};
-
-  if (_rawArgument != nullptr)
-  {
-    value = make_shared<int>();
-  }
-
-  this->argument = value;
-}
-
-NullPointerArgumentEvaluator::NullPointerArgumentEvaluator(const void *_rawArgument, string _message) : NullPointerArgumentEvaluator(_rawArgument)
-{
-  this->message = ::move(_message);
-}
-
 NullPointerArgumentEvaluator::NullPointerArgumentEvaluator(const shared_ptr<void> &_argument) : argument(_argument)
 {}
 

source/ls-std/core/evaluator/NullPointerEvaluator.cpp

@@ -3,7 +3,7 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-02-08
-* Changed:         2023-04-04
+* Changed:         2023-05-24
 *
 * */
 
@@ -17,23 +17,6 @@ using std::move;
 using std::shared_ptr;
 using std::string;
 
-NullPointerEvaluator::NullPointerEvaluator(const void *_rawArgument)
-{
-  shared_ptr<void> value{};
-
-  if (_rawArgument != nullptr)
-  {
-    value = make_shared<int>();
-  }
-
-  this->argument = value;
-}
-
-NullPointerEvaluator::NullPointerEvaluator(const void *_rawArgument, string _message) : NullPointerEvaluator(_rawArgument)
-{
-  this->message = ::move(_message);
-}
-
 NullPointerEvaluator::NullPointerEvaluator(const shared_ptr<void> &_argument) : argument(_argument)
 {}
 

source/ls-std/core/jni/JniApi.cpp

@@ -3,20 +3,21 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-04-07
-* Changed:         2023-05-16
+* Changed:         2023-05-23
 *
 * */
 
-#include <ls-std/core/evaluator/NullPointerArgumentEvaluator.hpp>
+#include <ls-std/core/evaluator/RawNullPointerArgumentEvaluator.hpp>
 #include <ls-std/core/jni/JniApi.hpp>
 
-using ls::std::core::NullPointerArgumentEvaluator;
+using ls::std::core::RawNullPointerArgumentEvaluator;
 using ls::std::core::experimental::JniApi;
+using ls::std::core::type::RawPointer;
 using std::string;
 
 JniApi::JniApi(JNIEnv *_environment) : environment(_environment)
 {
-  NullPointerArgumentEvaluator{_environment, "Java environment is not being provided!"}.evaluate();
+  RawNullPointerArgumentEvaluator<JNIEnv>{RawPointer<JNIEnv>{_environment}, "Java environment is not being provided!"}.evaluate();
 }
 
 JniApi::~JniApi() noexcept = default;

source/ls-std/core/jni/JniClass.cpp

@@ -3,14 +3,15 @@
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2023-04-07
-* Changed:         2023-05-16
+* Changed:         2023-05-24
 *
 * */
 
 #include <ls-std/core/ConditionalFunctionExecutor.hpp>
 #include <ls-std/core/evaluator/EmptyStringArgumentEvaluator.hpp>
 #include <ls-std/core/evaluator/NullPointerArgumentEvaluator.hpp>
-#include <ls-std/core/evaluator/NullPointerEvaluator.hpp>
+#include <ls-std/core/evaluator/RawNullPointerArgumentEvaluator.hpp>
+#include <ls-std/core/evaluator/RawNullPointerEvaluator.hpp>
 #include <ls-std/core/jni/JniApi.hpp>
 #include <ls-std/core/jni/JniClass.hpp>
 #include <memory>
@@ -18,12 +19,14 @@
 using ls::std::core::ConditionalFunctionExecutor;
 using ls::std::core::EmptyStringArgumentEvaluator;
 using ls::std::core::NullPointerArgumentEvaluator;
-using ls::std::core::NullPointerEvaluator;
+using ls::std::core::RawNullPointerArgumentEvaluator;
+using ls::std::core::RawNullPointerEvaluator;
 using ls::std::core::experimental::JniApi;
 using ls::std::core::experimental::JniClass;
 using ls::std::core::experimental::JniClassParameter;
 using ls::std::core::experimental::JniMethod;
 using ls::std::core::experimental::JniReturnValue;
+using ls::std::core::type::RawPointer;
 using std::make_pair;
 using std::make_shared;
 using std::pair;
@@ -34,7 +37,7 @@ JniClass::JniClass(const shared_ptr<JniClassParameter> &_parameter, const string
 {
   NullPointerArgumentEvaluator{_parameter, "no provided reference to JNI class parameter!"}.evaluate();
   EmptyStringArgumentEvaluator{_path, "path to associated Java class is empty!"}.evaluate();
-  NullPointerArgumentEvaluator{_parameter->getJavaEnvironment(), "Java environment is not being provided!"}.evaluate();
+  RawNullPointerArgumentEvaluator<JNIEnv>{RawPointer<JNIEnv>{_parameter->getJavaEnvironment()}, "Java environment is not being provided!"}.evaluate();
   ConditionalFunctionExecutor{_parameter->getJniApi() == nullptr}.execute([this]() { _createJniApi(); });
 }
 
@@ -72,7 +75,7 @@ bool JniClass::load()
 
 bool JniClass::loadMethod(const string &_methodIdentifier, const string &_methodSignature)
 {
-  NullPointerEvaluator{this->javaClass, "no Java class reference available for loading class method!"}.evaluate();
+  RawNullPointerEvaluator<_jclass>{RawPointer<_jclass>{this->javaClass}, "no Java class reference available for loading class method!"}.evaluate();
   jmethodID methodId = this->parameter->getJniApi()->getMethodId(this->javaClass, _methodIdentifier.c_str(), _methodSignature.c_str());
   bool succeeded = methodId != nullptr && !this->_hasMethod(_methodIdentifier);
 

test/cases/core/evaluator/RawNullPointerArgumentEvaluatorTest.cpp

@@ -0,0 +1,48 @@
+/*
+* Author:          Patrick-Christopher Mattulat
+* Company:         Lynar Studios
+* E-Mail:          webmaster@lynarstudios.com
+* Created:         2023-05-23
+* Changed:         2023-05-23
+*
+* */
+
+#include <gtest/gtest.h>
+#include <ls-std/ls-std-core.hpp>
+
+using ls::std::core::IllegalArgumentException;
+using ls::std::core::RawNullPointerArgumentEvaluator;
+using ls::std::core::type::RawPointer;
+using std::string;
+using testing::Test;
+
+namespace
+{
+  class RawNullPointerArgumentEvaluatorTest : public Test
+  {
+    public:
+
+      RawNullPointerArgumentEvaluatorTest() = default;
+      ~RawNullPointerArgumentEvaluatorTest() override = default;
+  };
+
+  TEST_F(RawNullPointerArgumentEvaluatorTest, evaluate_raw_pointer)
+  {
+    EXPECT_THROW(
+        {
+          try
+          {
+            RawNullPointerArgumentEvaluator<void>{RawPointer<void>{nullptr}}.evaluate();
+          }
+          catch (const IllegalArgumentException &_exception)
+          {
+            string actual = _exception.what();
+            string expected = _exception.getName() + " thrown - passed argument is null!";
+
+            ASSERT_STREQ(expected.c_str(), actual.c_str());
+            throw;
+          }
+        },
+        IllegalArgumentException);
+  }
+}

test/cases/core/evaluator/RawNullPointerEvaluatorTest.cpp

@@ -0,0 +1,48 @@
+/*
+* Author:          Patrick-Christopher Mattulat
+* Company:         Lynar Studios
+* E-Mail:          webmaster@lynarstudios.com
+* Created:         2023-05-24
+* Changed:         2023-05-24
+*
+* */
+
+#include <gtest/gtest.h>
+#include <ls-std/ls-std-core.hpp>
+
+using ls::std::core::NullPointerException;
+using ls::std::core::RawNullPointerEvaluator;
+using ls::std::core::type::RawPointer;
+using std::string;
+using testing::Test;
+
+namespace
+{
+  class RawNullPointerEvaluatorTest : public Test
+  {
+    public:
+
+      RawNullPointerEvaluatorTest() = default;
+      ~RawNullPointerEvaluatorTest() override = default;
+  };
+
+  TEST_F(RawNullPointerEvaluatorTest, evaluate_raw_pointer)
+  {
+    EXPECT_THROW(
+        {
+          try
+          {
+            RawNullPointerEvaluator<void>{RawPointer<void>{nullptr}}.evaluate();
+          }
+          catch (const NullPointerException &_exception)
+          {
+            string actual = _exception.what();
+            string expected = _exception.getName() + " thrown - reference in use is null!";
+
+            ASSERT_STREQ(expected.c_str(), actual.c_str());
+            throw;
+          }
+        },
+        NullPointerException);
+  }
+}