LCOV - code coverage report
Current view: top level - src/Helpers - unique_ptr.hpp (source / functions) Hit Total Coverage
Test: 19d2efc7037c2e176feca44750a12594c76f466f Lines: 23 24 95.8 %
Date: 2019-11-24 14:50:27 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : #pragma once
       2             : 
       3             : #ifndef DOXYGEN
       4             : 
       5             : template <class T>
       6             : struct remove_reference {
       7             :     typedef T type;
       8             : };
       9             : template <class T>
      10             : struct remove_reference<T &> {
      11             :     typedef T type;
      12             : };
      13             : template <class T>
      14             : struct remove_reference<T &&> {
      15             :     typedef T type;
      16             : };
      17             : 
      18             : template <class T>
      19             : typename remove_reference<T>::type &&move(T &&t) {
      20             :     return static_cast<typename remove_reference<T>::type &&>(t);
      21             : }
      22             : 
      23             : template <class T, T v>
      24             : struct integral_constant {
      25             :     constexpr static T value = v;
      26             : };
      27             : 
      28             : using true_type = integral_constant<bool, true>;
      29             : using false_type = integral_constant<bool, false>;
      30             : 
      31             : template <class T>
      32             : struct is_lvalue_reference : false_type {};
      33             : template <class T>
      34             : struct is_lvalue_reference<T &> : true_type {};
      35             : 
      36             : template <class T>
      37           1 : inline T &&forward(typename remove_reference<T>::type &t) noexcept {
      38           1 :     return static_cast<T &&>(t);
      39             : }
      40             : 
      41             : template <class T>
      42             : inline T &&forward(typename remove_reference<T>::type &&t) noexcept {
      43             :     static_assert(!is_lvalue_reference<T>::value,
      44             :                   "Can not forward an rvalue as an lvalue.");
      45             :     return static_cast<T &&>(t);
      46             : }
      47             : 
      48             : #endif
      49             : 
      50             : /// @addtogroup    Utilities
      51             : /// @{
      52             : 
      53             : /**
      54             :  * @brief   Very basic smart pointer. Doesn't support array types.
      55             :  * 
      56             :  * @tparam  T
      57             :  *          The type of the pointee.
      58             :  */
      59             : template <class T>
      60             : class unique_ptr {
      61             :   public:
      62             :     unique_ptr() = default;
      63           7 :     explicit unique_ptr(T *p) : p(p) {}
      64             :     unique_ptr(const unique_ptr &) = delete;
      65             :     template <class U>
      66           1 :     unique_ptr(unique_ptr<U> &&r) {
      67           1 :         reset(r.release());
      68           1 :     }
      69             : 
      70           8 :     ~unique_ptr() { delete p; }
      71             : 
      72             :     unique_ptr &operator=(const unique_ptr &) = delete;
      73           2 :     unique_ptr<T> &operator=(unique_ptr<T> &&r) {
      74           2 :         reset(r.release());
      75           2 :         return *this;
      76             :     }
      77             : 
      78           6 :     void reset(T *newP = nullptr) {
      79           6 :         T *old_ptr = p;
      80           6 :         p = newP;
      81           6 :         delete old_ptr;
      82           6 :     }
      83             : 
      84           4 :     T *release() {
      85           4 :         T *old_ptr = p;
      86           4 :         p = nullptr;
      87           4 :         return old_ptr;
      88             :     }
      89             : 
      90             :     explicit operator bool() const { return p != nullptr; }
      91             : 
      92             :     T *get() { return p; }
      93             :     const T *get() const { return p; }
      94             : 
      95           2 :     T *operator->() { return p; }
      96             :     const T *operator->() const { return p; }
      97             :     T &operator*() { return *p; }
      98             :     const T &operator*() const { return *p; }
      99             : 
     100             :   private:
     101           1 :     T *p = nullptr;
     102             : };
     103             : 
     104             : template <typename T, typename... Args>
     105           1 : unique_ptr<T> make_unique(Args &&... args) {
     106           1 :     return unique_ptr<T>(new T(forward<Args>(args)...));
     107           0 : }
     108             : 
     109             : /// @}

Generated by: LCOV version 1.14-5-g4ff2ed6