kstd: improve resemblence of STL

3 files changed, 48 insertions, 41 deletions

diff --git a/libs/kstd/include/kstd/shared_pointer.hpp b/libs/kstd/include/kstd/bits/shared_ptr.hpp
index 4717117..d41b165 100644
--- a/libs/kstd/include/kstd/shared_pointer.hpp
+++ b/libs/kstd/include/kstd/bits/shared_ptr.hpp
@@ -1,5 +1,5 @@
-#ifndef KSTD_SHARED_POINTER_HPP
-#define KSTD_SHARED_POINTER_HPP
+#ifndef KSTD_BITS_SHARED_PTR_HPP
+#define KSTD_BITS_SHARED_PTR_HPP
 
 #include <atomic>
 
@@ -7,10 +7,10 @@ namespace kstd
 {
   /**
    * @brief Shared_pointer is a smart pointer that retains shared ownership of an object through a pointer. Several
-   * shared_pointer objects may own the same object. The object is destroyed and its memory deallocated when either of
-   * the following happens: the last remaining shared_pointer owning the object is destroyed; the last remaining
-   * shared_pointer owning the object is assigned another pointer via operator= or reset(). A
-   * shared_pointer can share ownership of an object while storing a pointer to another object. This feature can be used
+   * shared_ptr objects may own the same object. The object is destroyed and its memory deallocated when either of
+   * the following happens: the last remaining shared_ptr owning the object is destroyed; the last remaining
+   * shared_ptr owning the object is assigned another pointer via operator= or reset(). A
+   * shared_ptr can share ownership of an object while storing a pointer to another object. This feature can be used
    * to point to member objects while owning the object they belong to. The stored pointer is the one accessed by get(),
    * the dereference and the comparison operators. The managed pointer is the one passed to the deleter when use count
    * reaches zero.
@@ -18,7 +18,7 @@ namespace kstd
    * @tparam T The type of the managed object.
    */
   template<typename T>
-  struct shared_pointer
+  struct shared_ptr
   {
     /**
      * @brief Constructor.
@@ -26,7 +26,7 @@ namespace kstd
      * @param pointer A pointer to an object to manage (default is nullptr).
      */
     [[gnu::section(".stl_text")]]
-    explicit shared_pointer(T * pointer = nullptr)
+    explicit shared_ptr(T * pointer = nullptr)
         : pointer(pointer)
         , ref_count(new std::atomic<std::size_t>(pointer != nullptr ? 1 : 0))
     {
@@ -36,10 +36,10 @@ namespace kstd
     /**
      * @brief Copy constructor.
      *
-     * @param other The shared_pointer to copy from.
+     * @param other The shared_ptr to copy from.
      */
     [[gnu::section(".stl_text")]]
-    shared_pointer(const shared_pointer & other)
+    shared_ptr(const shared_ptr & other)
         : pointer(other.pointer)
         , ref_count(other.ref_count)
     {
@@ -52,10 +52,10 @@ namespace kstd
     /**
      * @brief Move constructor.
      *
-     * @param other The shared_pointer to move from.
+     * @param other The shared_ptr to move from.
      */
     [[gnu::section(".stl_text")]]
-    shared_pointer(shared_pointer && other) noexcept
+    shared_ptr(shared_ptr && other) noexcept
         : pointer(other.pointer)
         , ref_count(other.ref_count)
     {
@@ -72,7 +72,7 @@ namespace kstd
      * @return Reference to this shared pointer.
      */
     [[gnu::section(".stl_text")]]
-    shared_pointer & operator=(const shared_pointer & other)
+    shared_ptr & operator=(const shared_ptr & other)
     {
       if (this != &other)
       {
@@ -97,7 +97,7 @@ namespace kstd
      * @return Reference to this shared pointer.
      */
     [[gnu::section(".stl_text")]]
-    shared_pointer & operator=(shared_pointer && other) noexcept
+    shared_ptr & operator=(shared_ptr && other) noexcept
     {
       if (this != &other)
       {
@@ -115,7 +115,7 @@ namespace kstd
      * @brief Destructor. Cleans up resources if necessary.
      */
     [[gnu::section(".stl_text")]]
-    ~shared_pointer()
+    ~shared_ptr()
     {
       cleanup();
     }
@@ -137,10 +137,10 @@ namespace kstd
      * @brief Exchanges the stored pointer values and the ownerships of *this and r. Reference counts, if any, are not
      * adjusted.
      *
-     * @param other The shared_pointer to swap with.
+     * @param other The shared_ptr to swap with.
      */
     [[gnu::section(".stl_text")]]
-    void swap(shared_pointer & other)
+    void swap(shared_ptr & other)
     {
       std::swap(pointer, other.pointer);
       std::swap(ref_count, other.ref_count);
@@ -180,7 +180,7 @@ namespace kstd
     }
 
     /**
-     * @brief Returns the number of different shared_pointer instances (*this included) managing the current object. If
+     * @brief Returns the number of different shared_ptr instances (*this included) managing the current object. If
      * there is no managed object, ​0​ is returned.
      *
      * @note Common use cases include comparison with ​0​. If use_count returns zero, the shared pointer is empty
@@ -216,7 +216,7 @@ namespace kstd
      * @brief Defaulted three-way comparator operator.
      */
     [[gnu::section(".stl_text")]]
-    auto operator<=>(const shared_pointer & other) const = default;
+    auto operator<=>(const shared_ptr & other) const = default;
 
   private:
     /**
@@ -244,15 +244,15 @@ namespace kstd
    * @param lhs, rhs Smart pointers whose contents to swap.
    */
   template<typename T>
-  auto swap(shared_pointer<T> & lhs, shared_pointer<T> & rhs) -> void
+  auto swap(shared_ptr<T> & lhs, shared_ptr<T> & rhs) -> void
   {
     lhs.swap(rhs);
   }
 
   /**
-   * @brief Constructs an object of type T and wraps it in a shared_pointer. Constructs a non-array type T. The
+   * @brief Constructs an object of type T and wraps it in a shared_ptr. Constructs a non-array type T. The
    * arguments args are passed to the constructor of T. This overload participates in overload resolution only if T is
-   * not an array type. The function is equivalent to: shared_pointer<T>(new T(std::forward<Args>(args)...)).
+   * not an array type. The function is equivalent to: shared_ptr<T>(new T(std::forward<Args>(args)...)).
    *
    * @tparam T Type of the managed object.
    * @tparam Args Argument types for T's constructor.
@@ -260,9 +260,9 @@ namespace kstd
    * @returns Shared_pointer of an instance of type T.
    */
   template<typename T, typename... Args>
-  auto make_shared(Args &&... args) -> shared_pointer<T>
+  auto make_shared(Args &&... args) -> shared_ptr<T>
   {
-    return shared_pointer<T>(new T(std::forward<Args>(args)...));
+    return shared_ptr<T>(new T(std::forward<Args>(args)...));
   }
 }  // namespace kstd
 
diff --git a/libs/kstd/include/kstd/unique_pointer.hpp b/libs/kstd/include/kstd/bits/unique_ptr.hpp
index 2861646..1932913 100644
--- a/libs/kstd/include/kstd/unique_pointer.hpp
+++ b/libs/kstd/include/kstd/bits/unique_ptr.hpp
@@ -1,5 +1,5 @@
-#ifndef KSTD_UNIQUE_POINTER_HPP
-#define KSTD_UNIQUE_POINTER_HPP
+#ifndef KSTD_BITS_UNIQUE_POINTER_HPP
+#define KSTD_BITS_UNIQUE_POINTER_HPP
 
 #include <utility>
 
@@ -7,12 +7,12 @@ namespace kstd
 {
   /**
    * @brief Unique_pointer is a smart pointer that owns (is responsible for) and manages another object via a pointer
-   * and subsequently disposes of that object when the unique_pointer goes out of scope.
+   * and subsequently disposes of that object when the unique_ptr goes out of scope.
    *
    * @tparam T Type of the managed object.
    */
   template<typename T>
-  struct unique_pointer
+  struct unique_ptr
   {
     /**
      * @brief Constructor.
@@ -20,7 +20,7 @@ namespace kstd
      * @param ptr A pointer to an object to manage (default is nullptr).
      */
     [[gnu::section(".stl_text")]]
-    explicit unique_pointer(T * ptr = nullptr)
+    explicit unique_ptr(T * ptr = nullptr)
         : pointer(ptr)
     {
       // Nothing to do.
@@ -30,7 +30,7 @@ namespace kstd
      * @brief Destructor that deletes the managed object.
      */
     [[gnu::section(".stl_text")]]
-    ~unique_pointer()
+    ~unique_ptr()
     {
       delete pointer;
     }
@@ -38,12 +38,12 @@ namespace kstd
     /**
      * @brief Deleted copy constructor to enforce unique ownership.
      */
-    unique_pointer(const unique_pointer &) = delete;
+    unique_ptr(const unique_ptr &) = delete;
 
     /**
      * @brief Deleted copy assignment operator to enforce unique ownership.
      */
-    auto operator=(const unique_pointer &) -> unique_pointer & = delete;
+    auto operator=(const unique_ptr &) -> unique_ptr & = delete;
 
     /**
      * @brief Move constructor.
@@ -51,7 +51,7 @@ namespace kstd
      * @param other Unique pointer to move from.
      */
     [[gnu::section(".stl_text")]]
-    unique_pointer(unique_pointer && other) noexcept
+    unique_ptr(unique_ptr && other) noexcept
         : pointer(other.pointer)
     {
       other.pointer = nullptr;
@@ -64,7 +64,7 @@ namespace kstd
      * @return Reference to this unique pointer.
      */
     [[gnu::section(".stl_text")]]
-    auto operator=(unique_pointer && other) noexcept -> unique_pointer &
+    auto operator=(unique_ptr && other) noexcept -> unique_ptr &
     {
       if (this != &other)
       {
@@ -157,7 +157,7 @@ namespace kstd
      * @param other Another unique_ptr object to swap the managed object and the deleter with.
      */
     [[gnu::section(".stl_text")]]
-    auto swap(unique_pointer & other) -> void
+    auto swap(unique_ptr & other) -> void
     {
       using std::swap;
       swap(pointer, other.pointer);
@@ -167,7 +167,7 @@ namespace kstd
      * @brief Defaulted three-way comparator operator.
      */
     [[gnu::section(".stl_text")]]
-    auto operator<=>(const unique_pointer & other) const = default;
+    auto operator<=>(const unique_ptr & other) const = default;
 
   private:
     T * pointer;  ///< The managed pointer.
@@ -181,15 +181,15 @@ namespace kstd
    * @param lhs, rhs Smart pointers whose contents to swap.
    */
   template<typename T>
-  auto swap(unique_pointer<T> & lhs, unique_pointer<T> & rhs) -> void
+  auto swap(unique_ptr<T> & lhs, unique_ptr<T> & rhs) -> void
   {
     lhs.swap(rhs);
   }
 
   /**
-   * @brief Constructs an object of type T and wraps it in a unique_pointer. Constructs a non-array type T. The
+   * @brief Constructs an object of type T and wraps it in a unique_ptr. Constructs a non-array type T. The
    * arguments args are passed to the constructor of T. This overload participates in overload resolution only if T is
-   * not an array type. The function is equivalent to: unique_pointer<T>(new T(std::forward<Args>(args)...)).
+   * not an array type. The function is equivalent to: unique_ptr<T>(new T(std::forward<Args>(args)...)).
    *
    * @tparam T Type of the managed object.
    * @tparam Args Argument types for T's constructor.
@@ -197,9 +197,9 @@ namespace kstd
    * @returns Unique_pointer of an instance of type T.
    */
   template<typename T, typename... Args>
-  auto make_unique(Args &&... args) -> unique_pointer<T>
+  auto make_unique(Args &&... args) -> unique_ptr<T>
   {
-    return unique_pointer<T>(new T(std::forward<Args>(args)...));
+    return unique_ptr<T>(new T(std::forward<Args>(args)...));
   }
 }  // namespace kstd
 
diff --git a/libs/kstd/include/kstd/memory.hpp b/libs/kstd/include/kstd/memory.hpp
new file mode 100644
index 0000000..cab2fba
--- /dev/null
+++ b/libs/kstd/include/kstd/memory.hpp
@@ -0,0 +1,7 @@
+#ifndef KSTD_SHARED_POINTER_HPP
+#define KSTD_SHARED_POINTER_HPP
+
+#include "kstd/bits/shared_ptr.hpp"  // IWYU pragma: export
+#include "kstd/bits/unique_ptr.hpp"  // IWYU pragma: export
+
+#endif
\ No newline at end of file