libs: move shared_pointer to kstd

1 files changed, 0 insertions, 269 deletions

diff --git a/arch/x86_64/include/arch/stl/shared_pointer.hpp b/arch/x86_64/include/arch/stl/shared_pointer.hpp
deleted file mode 100644
index c9796a8..0000000
--- a/arch/x86_64/include/arch/stl/shared_pointer.hpp
+++ /dev/null
@@ -1,269 +0,0 @@
-#ifndef TEACHOS_ARCH_X86_64_STL_SHARED_POINTER_HPP
-#define TEACHOS_ARCH_X86_64_STL_SHARED_POINTER_HPP
-
-#include <atomic>
-
-namespace teachos::arch::stl
-{
-  /**
-   * @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
-   * 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.
-   *
-   * @tparam T The type of the managed object.
-   */
-  template<typename T>
-  struct shared_pointer
-  {
-    /**
-     * @brief Constructor.
-     *
-     * @param pointer A pointer to an object to manage (default is nullptr).
-     */
-    [[gnu::section(".stl_text")]]
-    explicit shared_pointer(T * pointer = nullptr)
-        : pointer(pointer)
-        , ref_count(new std::atomic<std::size_t>(pointer != nullptr ? 1 : 0))
-    {
-      // Nothing to do.
-    }
-
-    /**
-     * @brief Copy constructor.
-     *
-     * @param other The shared_pointer to copy from.
-     */
-    [[gnu::section(".stl_text")]]
-    shared_pointer(const shared_pointer & other)
-        : pointer(other.pointer)
-        , ref_count(other.ref_count)
-    {
-      if (pointer != nullptr)
-      {
-        ++(*ref_count);
-      }
-    }
-
-    /**
-     * @brief Move constructor.
-     *
-     * @param other The shared_pointer to move from.
-     */
-    [[gnu::section(".stl_text")]]
-    shared_pointer(shared_pointer && other) noexcept
-        : pointer(other.pointer)
-        , ref_count(other.ref_count)
-    {
-      other.pointer = nullptr;
-      other.ref_count = nullptr;
-    }
-
-    /**
-     * @brief Copy assignment operator. Replaces the managed object with the one managed by r. Shares ownership of the
-     * object managed by r. If r manages no object, *this manages no object too. Equivalent to
-     * shared_ptr<T>(r).swap(*this).
-     *
-     * @param other Another smart pointer to share the ownership with.
-     * @return Reference to this shared pointer.
-     */
-    [[gnu::section(".stl_text")]]
-    shared_pointer & operator=(const shared_pointer & other)
-    {
-      if (this != &other)
-      {
-        cleanup();
-        pointer = other.pointer;
-        ref_count = other.ref_count;
-
-        if (pointer != nullptr)
-        {
-          ++(*ref_count);
-        }
-      }
-
-      return *this;
-    }
-
-    /**
-     * @brief Move assignment operator. Move-assigns a shared_ptr from r. After the assignment, *this contains a copy of
-     * the previous state of r, and r is empty. Equivalent to shared_ptr<T>(std::move(r)).swap(*this).
-     *
-     * @param other Another smart pointer to acquire the ownership from.
-     * @return Reference to this shared pointer.
-     */
-    [[gnu::section(".stl_text")]]
-    shared_pointer & operator=(shared_pointer && other) noexcept
-    {
-      if (this != &other)
-      {
-        cleanup();
-        pointer = other.pointer;
-        ref_count = other.ref_count;
-        other.pointer = nullptr;
-        other.ref_count = nullptr;
-      }
-
-      return *this;
-    }
-
-    /**
-     * @brief Destructor. Cleans up resources if necessary.
-     */
-    [[gnu::section(".stl_text")]]
-    ~shared_pointer()
-    {
-      cleanup();
-    }
-
-    /**
-     * @brief Replaces the managed object.
-     *
-     * @param ptr Pointer to a new object to manage (default = nullptr).
-     */
-    [[gnu::section(".stl_text")]]
-    void reset(T * ptr = nullptr)
-    {
-      cleanup();
-      pointer = ptr;
-      ref_count = new std::atomic<std::size_t>(ptr != nullptr ? 1 : 0);
-    }
-
-    /**
-     * @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.
-     */
-    [[gnu::section(".stl_text")]]
-    void swap(shared_pointer & other)
-    {
-      std::swap(pointer, other.pointer);
-      std::swap(ref_count, other.ref_count);
-    }
-
-    /**
-     * @brief Dereference operator. If get() is a null pointer, the behavior is undefined.
-     *
-     * @return Returns the object owned by *this, equivalent to *get().
-     */
-    [[gnu::section(".stl_text")]]
-    auto operator*() const -> T &
-    {
-      return *pointer;
-    }
-
-    /**
-     * @brief Member access operator.
-     *
-     * @return Returns a pointer to the object owned by *this, i.e. get().
-     */
-    [[gnu::section(".stl_text")]]
-    auto operator->() const -> T *
-    {
-      return pointer;
-    }
-
-    /**
-     * @brief Returns a pointer to the managed object or nullptr if no object is owned.
-     *
-     * @return Pointer to the managed object or nullptr if no object is owned.
-     */
-    [[gnu::section(".stl_text")]]
-    auto get() const -> T *
-    {
-      return pointer;
-    }
-
-    /**
-     * @brief Returns the number of different shared_pointer 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
-     * and manages no objects (whether or not its stored pointer is nullptr). Comparison with 1. If use_count returns 1,
-     * there are no other owners.
-     *
-     * @return The number of Shared_pointer instances managing the current object or ​0​ if there is no managed
-     * object.
-     */
-    [[gnu::section(".stl_text")]]
-    auto use_count() const -> std::size_t
-    {
-      if (pointer != nullptr)
-      {
-        return *ref_count;
-      }
-
-      return 0;
-    }
-
-    /**
-     * @brief Checks whether *this owns an object, i.e. whether get() != nullptr.
-     *
-     * @return true if *this owns an object, false otherwise.
-     */
-    [[gnu::section(".stl_text")]]
-    explicit operator bool() const
-    {
-      return pointer != nullptr;
-    }
-
-    /**
-     * @brief Defaulted three-way comparator operator.
-     */
-    [[gnu::section(".stl_text")]]
-    auto operator<=>(const shared_pointer & other) const = default;
-
-  private:
-    /**
-     * @brief Releases ownership and deletes the object if this was the last ereference to the owned managed object.
-     */
-    [[gnu::section(".stl_text")]]
-    auto cleanup() -> void
-    {
-      if (pointer != nullptr && ref_count != nullptr && --(*ref_count) == 0)
-      {
-        delete pointer;
-        delete ref_count;
-      }
-    }
-
-    T * pointer;                           ///< The managed object.
-    std::atomic<std::size_t> * ref_count;  ///< Reference count.
-  };
-
-  /**
-   * @brief Specializes the std::swap algorithm for stl::unique_ptr. Swaps the contents of lhs and rhs. Calls
-   * lhs.swap(rhs).
-   *
-   * @tparam T Type of the managed object.
-   * @param lhs, rhs Smart pointers whose contents to swap.
-   */
-  template<typename T>
-  auto swap(shared_pointer<T> & lhs, shared_pointer<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
-   * 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)...)).
-   *
-   * @tparam T Type of the managed object.
-   * @tparam Args Argument types for T's constructor.
-   * @param args List of arguments with which an instance of T will be constructed.
-   * @returns Shared_pointer of an instance of type T.
-   */
-  template<typename T, typename... Args>
-  auto make_shared(Args &&... args) -> shared_pointer<T>
-  {
-    return shared_pointer<T>(new T(std::forward<Args>(args)...));
-  }
-}  // namespace teachos::arch::stl
-
-#endif  // TEACHOS_ARCH_X86_64_STL_SHARED_POINTER_HPP
\ No newline at end of file