ownerPtr.h

Go to the documentation of this file.

#ifndef OWNERPTR_H
#define OWNERPTR_H
 
#include <utility>
#include "autoPtr.h"
#include "deleter.h"

 
namespace original {
    template <typename TYPE, typename DELETER = deleter<TYPE>>
    class ownerPtr final : public autoPtr<TYPE, ownerPtr<TYPE, DELETER>, DELETER>{
    public:
        explicit ownerPtr(TYPE* p = std::nullptr_t{});
 
        ownerPtr(const ownerPtr& other) = delete; 
        ownerPtr& operator=(const ownerPtr& other) = delete; 

        ownerPtr(ownerPtr&& other) noexcept;

        ownerPtr& operator=(ownerPtr&& other) noexcept;

        TYPE* unlock();

        [[nodiscard]] std::string className() const override;

        ~ownerPtr() override;
 
        // Factory friend functions
        template <typename T, typename DEL, typename... Args>
        friend ownerPtr<T, DEL> makeOwnerPtr(Args&&... args);
 
        template <typename T, typename DEL, typename... Args>
        friend ownerPtr<T, DEL> makeOwnerPtrArray(u_integer size, Args&&... args);
    };

    template <typename T, typename DEL = deleter<T>, typename... Args>
    ownerPtr<T, DEL> makeOwnerPtr(Args&&... args);

    template <typename T, typename DEL = deleter<T[]>, typename... Args>
    ownerPtr<T, DEL> makeOwnerPtrArray(u_integer size, Args&&... args);
 
 
    // ----------------- Definitions of ownerPtr.h -----------------
 
 
    template<typename TYPE, typename DELETER>
    ownerPtr<TYPE, DELETER>::ownerPtr(TYPE *p)
        : autoPtr<TYPE, ownerPtr, DELETER>(p) {
        this->addStrongRef();
    }
 
    template<typename TYPE, typename DELETER>
    ownerPtr<TYPE, DELETER>::ownerPtr(ownerPtr &&other) noexcept : ownerPtr(){
        this->operator=(std::move(other));
    }
 
    template<typename TYPE, typename DELETER>
    ownerPtr<TYPE, DELETER>& ownerPtr<TYPE, DELETER>::operator=(ownerPtr&& other) noexcept {
        if (this == &other)
            return *this;
 
        this->removeStrongRef();
        this->clean();
        this->ref_count = other.ref_count;
        other.ref_count = autoPtr<TYPE, ownerPtr, DELETER>::newRefCount();
        other.addStrongRef();
        return *this;
    }
 
    template<typename TYPE, typename DELETER>
    TYPE* ownerPtr<TYPE, DELETER>::unlock() {
        TYPE* p = this->get();
        this->setPtr(nullptr);
        return p;
    }
 
    template<typename TYPE, typename DELETER>
    std::string ownerPtr<TYPE, DELETER>::className() const {
        return "ownerPtr";
    }
 
    template<typename TYPE, typename DELETER>
    ownerPtr<TYPE, DELETER>::~ownerPtr() {
        this->removeStrongRef();
    }
 
    template<typename T, typename DEL, typename ... Args>
    ownerPtr<T, DEL> makeOwnerPtr(Args &&...args) {
        return ownerPtr<T, DEL>(new T{std::forward<Args>(args)...});
    }
 
    template<typename T, typename DEL, typename ... Args>
    ownerPtr<T, DEL> makeOwnerPtrArray(const u_integer size, Args&& ...args) {
        auto owner_ptr = ownerPtr<T, DEL>(new T[size]);
        for (u_integer i = 0; i < size; i++)
        {
            owner_ptr[i] = T(std::forward<Args>(args)...);
        }
        return owner_ptr;
    }
}
 
#endif //OWNERPTR_H