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>{
        template<typename, typename> friend class ownerPtr;
    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;
 
        template<typename U, typename DEL = DELETER::template rebound_deleter<U>>
        ownerPtr<U, DEL> staticCastMoveTo();
 
        template<typename U, typename DEL = DELETER::template rebound_deleter<U>>
        ownerPtr<U, DEL> dynamicCastMoveTo();
 
        template<typename U, typename DEL = DELETER::template rebound_deleter<U>>
        ownerPtr<U, DEL> constCastMoveTo();
 
        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>
    template<typename U, typename DEL>
    ownerPtr<U, DEL>
    ownerPtr<TYPE, DELETER>::staticCastMoveTo() {
        return ownerPtr<U, DEL>{
            static_cast<U*>(this->unlock())
        };
    }
 
    template <typename TYPE, typename DELETER>
    template<typename U, typename DEL>
    ownerPtr<U, DEL>
    ownerPtr<TYPE, DELETER>::dynamicCastMoveTo() {
        auto p = dynamic_cast<U*>(this->get());
        if (p == nullptr) {
            return ownerPtr<U, DEL>{};
        }
        this->unlock();
        return ownerPtr<U, DEL>{p};
    }
 
    template <typename TYPE, typename DELETER>
    template<typename U, typename DEL>
    ownerPtr<U, DEL>
    ownerPtr<TYPE, DELETER>::constCastMoveTo() {
        return ownerPtr<U, DEL>{
            const_cast<U*>(this->unlock())
        };
    }
 
    template<typename TYPE, typename DELETER>
    TYPE* ownerPtr<TYPE, DELETER>::unlock() {
        return this->releasePtr();
    }
 
    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