refactor: move UniquePtr to memory dir in common

6 files changed, 96 insertions, 81 deletions

diff --git a/src/common/conversion.cpp b/src/common/conversion.cpp
index 0bdc81a..b016537 100644
--- a/src/common/conversion.cpp
+++ b/src/common/conversion.cpp
@@ -1,5 +1,8 @@
 #include "conversion.hpp"
 
+#include <math.h>
+#include <stdlib.h>
+
 namespace common
 {
 
diff --git a/src/common/conversion.hpp b/src/common/conversion.hpp
index 81a4a52..e87adc5 100644
--- a/src/common/conversion.hpp
+++ b/src/common/conversion.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "common/memory.hpp"
+#include "common/memory/unique_ptr.hpp"
 #include "common/string.hpp"
 
 namespace common
diff --git a/src/common/memory.hpp b/src/common/memory.hpp
index de72d80..888ede3 100644
--- a/src/common/memory.hpp
+++ b/src/common/memory.hpp
@@ -8,37 +8,6 @@ namespace common
 template <typename memType>
 memType *malloc_s(unsigned int size);
 
-template <class Target>
-class UniquePtr
-{
-public:
-	explicit UniquePtr() = default;
-	explicit UniquePtr(Target *target);
-
-	// Move constructor
-	UniquePtr(UniquePtr &&unique_ptr) noexcept;
-
-	// Move assignment operator
-	UniquePtr &operator=(UniquePtr &&unique_ptr) noexcept;
-
-	// Disable the copy constructor
-	UniquePtr(const UniquePtr &unique_ptr) = delete;
-
-	// Disable the copy assignment operator
-	UniquePtr &operator=(const UniquePtr &unique_ptr) = delete;
-
-	~UniquePtr();
-
-	Target operator*() const;
-	Target *operator->() const;
-
-private:
-	Target *_target = nullptr;
-};
-
-template <typename Target, typename... Args>
-UniquePtr<Target> make_unique(Args... args);
-
 } // namespace common
 
 #include "memory.tpp"
diff --git a/src/common/memory.tpp b/src/common/memory.tpp
index ace2432..af833bc 100644
--- a/src/common/memory.tpp
+++ b/src/common/memory.tpp
@@ -24,53 +24,4 @@ memType *malloc_s(unsigned int size)
 	return static_cast<memType *>(mem);
 }
 
-template <class Target>
-UniquePtr<Target>::UniquePtr(Target *target) : _target(target)
-{
-}
-
-template <class Target>
-UniquePtr<Target>::UniquePtr(UniquePtr &&unique_ptr) noexcept
-	: _target(unique_ptr._target)
-{
-	unique_ptr._target = nullptr;
-}
-
-template <class Target>
-UniquePtr<Target> &UniquePtr<Target>::operator=(UniquePtr &&unique_ptr) noexcept
-{
-	if (&unique_ptr != this)
-	{
-		delete _target;
-		_target = unique_ptr._target;
-		unique_ptr._target = nullptr;
-	}
-
-	return *this;
-}
-
-template <class Target>
-UniquePtr<Target>::~UniquePtr()
-{
-	delete _target;
-}
-
-template <class Target>
-Target UniquePtr<Target>::operator*() const
-{
-	return *(_target);
-}
-
-template <class Target>
-Target *UniquePtr<Target>::operator->() const
-{
-	return _target;
-}
-
-template <class Target, typename... Args>
-UniquePtr<Target> make_unique(Args... args)
-{
-	return UniquePtr<Target>(new Target(args...));
-}
-
 } // namespace common
diff --git a/src/common/memory/unique_ptr.hpp b/src/common/memory/unique_ptr.hpp
new file mode 100644
index 0000000..94c02d0
--- /dev/null
+++ b/src/common/memory/unique_ptr.hpp
@@ -0,0 +1,37 @@
+#pragma once

+

+namespace common

+{

+template <class Target>

+class UniquePtr

+{

+public:

+	explicit UniquePtr() = default;

+	explicit UniquePtr(Target *target);

+

+	// Move constructor

+	UniquePtr(UniquePtr &&unique_ptr) noexcept;

+

+	// Move assignment operator

+	UniquePtr &operator=(UniquePtr &&unique_ptr) noexcept;

+

+	// Disable the copy constructor

+	UniquePtr(const UniquePtr &unique_ptr) = delete;

+

+	// Disable the copy assignment operator

+	UniquePtr &operator=(const UniquePtr &unique_ptr) = delete;

+

+	~UniquePtr();

+

+	Target operator*() const;

+	Target *operator->() const;

+

+private:

+	Target *_target = nullptr;

+};

+

+template <typename Target, typename... Args>

+UniquePtr<Target> make_unique(Args... args);

+} // namespace common

+

+#include "unique_ptr.tpp"

diff --git a/src/common/memory/unique_ptr.tpp b/src/common/memory/unique_ptr.tpp
new file mode 100644
index 0000000..3cab9ec
--- /dev/null
+++ b/src/common/memory/unique_ptr.tpp
@@ -0,0 +1,55 @@
+#pragma once

+

+#include "unique_ptr.hpp"

+

+namespace common

+{

+template <class Target>

+UniquePtr<Target>::UniquePtr(Target *target) : _target(target)

+{

+}

+

+template <class Target>

+UniquePtr<Target>::UniquePtr(UniquePtr &&unique_ptr) noexcept

+	: _target(unique_ptr._target)

+{

+	unique_ptr._target = nullptr;

+}

+

+template <class Target>

+UniquePtr<Target> &UniquePtr<Target>::operator=(UniquePtr &&unique_ptr) noexcept

+{

+	if (&unique_ptr != this)

+	{

+		delete _target;

+		_target = unique_ptr._target;

+		unique_ptr._target = nullptr;

+	}

+

+	return *this;

+}

+

+template <class Target>

+UniquePtr<Target>::~UniquePtr()

+{

+	delete _target;

+}

+

+template <class Target>

+Target UniquePtr<Target>::operator*() const

+{

+	return *(_target);

+}

+

+template <class Target>

+Target *UniquePtr<Target>::operator->() const

+{

+	return _target;

+}

+

+template <class Target, typename... Args>

+UniquePtr<Target> make_unique(Args... args)

+{

+	return UniquePtr<Target>(new Target(args...));

+}

+} // namespace common