Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include <AH/Settings/Warnings.hpp>
       4             : AH_DIAGNOSTIC_WERROR() // Enable errors on warnings
       5             : 
       6             : #include <AH/STL/type_traits>
       7             : #include <AH/STL/utility> // std::forward
       8             : 
       9             : BEGIN_AH_NAMESPACE
      10             : 
      11             : /// @addtogroup    AH_Containers
      12             : /// @{
      13             : 
      14             : /**
      15             :  * @brief   Very basic smart pointer. Doesn't support array types.
      16             :  * 
      17             :  * @tparam  T
      18             :  *          The type of the pointee.
      19             :  */
      20             : template <class T>
      21             : class UniquePtr {
      22             :   public:
      23             :     UniquePtr() = default;
      24           7 :     explicit UniquePtr(T *p) : p(p) {}
      25             :     UniquePtr(const UniquePtr &) = delete;
      26             :     template <class U>
      27           1 :     UniquePtr(UniquePtr<U> &&r) {
      28           1 :         reset(r.release());
      29           1 :     }
      30             : 
      31           8 :     ~UniquePtr() { delete p; }
      32             : 
      33             :     UniquePtr &operator=(const UniquePtr &) = delete;
      34           2 :     UniquePtr<T> &operator=(UniquePtr<T> &&r) {
      35           2 :         reset(r.release());
      36           2 :         return *this;
      37             :     }
      38             : 
      39           6 :     void reset(T *newP = nullptr) {
      40           6 :         T *old_ptr = p;
      41           6 :         p = newP;
      42           6 :         delete old_ptr;
      43           6 :     }
      44             : 
      45           4 :     T *release() {
      46           4 :         T *old_ptr = p;
      47           4 :         p = nullptr;
      48           4 :         return old_ptr;
      49             :     }
      50             : 
      51             :     explicit operator bool() const { return p != nullptr; }
      52             : 
      53             :     T *get() { return p; }
      54             :     const T *get() const { return p; }
      55             : 
      56           2 :     T *operator->() { return p; }
      57             :     const T *operator->() const { return p; }
      58             :     T &operator*() { return *p; }
      59             :     const T &operator*() const { return *p; }
      60             : 
      61             :   private:
      62           1 :     T *p = nullptr;
      63             : };
      64             : 
      65             : template <typename T, typename... Args>
      66           1 : UniquePtr<T> MakeUnique(Args &&... args) {
      67           1 :     return UniquePtr<T>(new T(std::forward<Args>(args)...));
      68           0 : }
      69             : 
      70             : /// @}
      71             : 
      72             : END_AH_NAMESPACE
      73             : 
      74             : AH_DIAGNOSTIC_POP()