refCntPtr.h

Go to the documentation of this file.

#ifndef REFCNTPTR_H
#define REFCNTPTR_H
 
#include "autoPtr.h"
#include "deleter.h"
#include "refCntPtr.h"
 
namespace original{
    template<typename TYPE, typename DERIVED, typename DELETER>
    class refCntPtr : public autoPtr<TYPE, DERIVED, DELETER>{
        template<typename, typename, typename> friend class refCntPtr;
    protected:
        explicit refCntPtr(TYPE* p = std::nullptr_t{});
    public:
        using autoPtr<TYPE, DERIVED, DELETER>::operator==;
        using autoPtr<TYPE, DERIVED, DELETER>::operator!=;
 
        template<typename O_DERIVED>
        bool operator==(const refCntPtr<TYPE, O_DERIVED, DELETER>& other) const;
 
        template<typename O_DERIVED>
        bool operator!=(const refCntPtr<TYPE, O_DERIVED, DELETER>& other) const;
 
        [[nodiscard]] std::string className() const override;
 
        [[nodiscard]] std::string toString(bool enter) const override;
 
        ~refCntPtr() override = default;
    };
 
    template<typename TYPE, typename DELETER = deleter<TYPE>>
    class strongPtr;
 
    template<typename TYPE, typename DELETER = deleter<TYPE>>
    class weakPtr;
 
    template<typename TYPE, typename DELETER>
    class strongPtr final : public refCntPtr<TYPE, strongPtr<TYPE, DELETER>, DELETER>{
        template<typename, typename> friend class strongPtr;
        template<typename, typename> friend class weakPtr;
 
        strongPtr(refCountBase* cnt, TYPE* alias);
    public:
        explicit strongPtr(TYPE* p = std::nullptr_t{});
 
        strongPtr(const strongPtr& other);
 
        strongPtr& operator=(const strongPtr& other);
 
        strongPtr(strongPtr&& other) noexcept;
 
        template<typename U, typename DEL = DELETER::template rebound_deleter<U>>
        strongPtr<U, DEL> staticCastTo();
 
        template<typename U, typename DEL = DELETER::template rebound_deleter<const U>>
        strongPtr<const U, DEL> staticCastTo() const;
 
        template<typename U, typename DEL = DELETER::template rebound_deleter<U>>
        strongPtr<U, DEL> dynamicCastTo();
 
        template<typename U, typename DEL = DELETER::template rebound_deleter<const U>>
        strongPtr<const U, DEL> dynamicCastTo() const;
 
        template<typename U, typename DEL = DELETER::template rebound_deleter<U>>
        strongPtr<U, DEL> constCastTo() const;
 
        void reset() noexcept;
 
        strongPtr& operator=(strongPtr&& other) noexcept;
 
        [[nodiscard]] std::string className() const override;
 
        ~strongPtr() override;
 
        template <typename T, typename DEL, typename... Args>
        friend strongPtr<T, DEL> makeStrongPtr(Args&&... args);
 
        template <typename T, typename DEL, typename... Args>
        friend strongPtr<T, DEL> makeStrongPtrArray(u_integer size, Args&&... args);
    };
 
    template<typename TYPE, typename DELETER>
    class weakPtr final : public refCntPtr<TYPE, weakPtr<TYPE, DELETER>, DELETER>{
        template<typename, typename> friend class weakPtr;
        template<typename, typename> friend class strongPtr;
 
        weakPtr(refCountBase* cnt, TYPE* alias);
    public:
 
        explicit weakPtr();
 
        explicit weakPtr(const strongPtr<TYPE, DELETER>& other);
 
        weakPtr& operator=(const strongPtr<TYPE, DELETER>& other);
 
        weakPtr(const weakPtr& other);
 
        weakPtr& operator=(const weakPtr& other);
 
        weakPtr(weakPtr&& other) noexcept;
 
        weakPtr& operator=(weakPtr&& other) noexcept;
 
        template<typename U, typename DEL = DELETER::template rebound_deleter<U>>
        weakPtr<U, DEL> staticCastTo();
 
        template<typename U, typename DEL = DELETER::template rebound_deleter<const U>>
        weakPtr<const U, DEL> staticCastTo() const;
 
        template<typename U, typename DEL = DELETER::template rebound_deleter<U>>
        weakPtr<U, DEL> dynamicCastTo();
 
        template<typename U, typename DEL = DELETER::template rebound_deleter<const U>>
        weakPtr<const U, DEL> dynamicCastTo() const;
 
        template<typename U, typename DEL = DELETER::template rebound_deleter<U>>
        weakPtr<U, DEL> constCastTo() const;
 
        strongPtr<TYPE, DELETER> lock() const;
 
        const TYPE& operator*() const override;
 
        const TYPE* operator->() const override;
 
        const TYPE& operator[](u_integer index) const override;
 
        TYPE& operator*() override;
 
        TYPE* operator->() override;
 
        TYPE& operator[](u_integer index) override;
 
        [[nodiscard]] std::string className() const override;
 
        ~weakPtr() override;
    };
 
    template <typename T, typename DEL = deleter<T>, typename... Args>
    strongPtr<T, DEL> makeStrongPtr(Args&&... args);
 
    template <typename T, typename DEL = deleter<T[]>, typename... Args>
    strongPtr<T, DEL> makeStrongPtrArray(u_integer size, Args&&... args);
 
    // ----------------- Definitions of refCntPtr.h -----------------
 
 
    template<typename TYPE, typename DERIVED, typename DELETER>
    refCntPtr<TYPE, DERIVED, DELETER>::refCntPtr(TYPE *p)
        : autoPtr<TYPE, DERIVED, DELETER>::autoPtr(p) {}
 
    template<typename TYPE, typename DERIVED, typename DELETER>
    template<typename O_DERIVED>
    bool refCntPtr<TYPE, DERIVED, DELETER>::operator==(const refCntPtr<TYPE, O_DERIVED, DELETER>& other) const {
        return this->get() == other.get();
    }
 
    template<typename TYPE, typename DERIVED, typename DELETER>
    template<typename O_DERIVED>
    bool refCntPtr<TYPE, DERIVED, DELETER>::operator!=(const refCntPtr<TYPE, O_DERIVED, DELETER>& other) const {
        return this->get() != other.get();
    }
 
    template<typename TYPE, typename DERIVED, typename DELETER>
    std::string refCntPtr<TYPE, DERIVED, DELETER>::className() const {
        return "refCntPtr";
    }
 
    template<typename TYPE, typename DERIVED, typename DELETER>
    std::string refCntPtr<TYPE, DERIVED, DELETER>::toString(const bool enter) const {
        std::stringstream ss;
        ss << this->className() << "(";
        ss << printable::formatString(this->get()) << ", ";
        ss << "strong ref: " << this->strongRefs() << ", " << "weak ref: " << this->weakRefs();
        ss << ")";
        if (enter)
            ss << "\n";
        return ss.str();
    }
 
    template <typename TYPE, typename DELETER>
    strongPtr<TYPE, DELETER>::strongPtr(refCountBase* cnt, TYPE* alias) : strongPtr()
    {
        this->removeStrongRef();
        this->clean();
        this->ref_count = cnt;
        this->alias_ptr = alias;
        this->addStrongRef();
    }
 
    template<typename TYPE, typename DELETER>
    strongPtr<TYPE, DELETER>::strongPtr(TYPE *p)
        : refCntPtr<TYPE, strongPtr, DELETER>(p) {
        this->addStrongRef();
    }
 
    template<typename TYPE, typename DELETER>
    strongPtr<TYPE, DELETER>::strongPtr(const strongPtr& other) : strongPtr(){
        this->operator=(other);
    }
 
    template<typename TYPE, typename DELETER>
    strongPtr<TYPE, DELETER>& strongPtr<TYPE, DELETER>::operator=(const strongPtr& other) {
        if (this == &other || *this == other)
            return *this;
 
        this->removeStrongRef();
        this->clean();
        this->ref_count = *other.ref_count;
        this->addStrongRef();
        this->alias_ptr = other.alias_ptr;
        return *this;
    }
 
    template<typename TYPE, typename DELETER>
    strongPtr<TYPE, DELETER>::strongPtr(strongPtr&& other) noexcept : strongPtr() {
        this->operator=(std::move(other));
    }
 
    template <typename TYPE, typename DELETER>
    template <typename U, typename DEL>
    strongPtr<U, DEL> strongPtr<TYPE, DELETER>::staticCastTo()
    {
        staticError<valueError, !std::is_convertible_v<TYPE*, U*>>::asserts();
        strongPtr<U, DEL> res{*this->ref_count, static_cast<U*>(this->get())};
        return res;
    }
 
    template <typename TYPE, typename DELETER>
    template <typename U, typename DEL>
    strongPtr<const U, DEL> strongPtr<TYPE, DELETER>::staticCastTo() const
    {
        staticError<valueError, !std::is_convertible_v<TYPE*, U*>>::asserts();
        strongPtr<const U, DEL> res{*this->ref_count, static_cast<const U*>(this->get())};
        return res;
    }
 
    template <typename TYPE, typename DELETER>
    template <typename U, typename DEL>
    strongPtr<U, DEL> strongPtr<TYPE, DELETER>::dynamicCastTo()
    {
        auto alias = dynamic_cast<U*>(this->get());
        if (alias == nullptr) {
            return strongPtr<U, DEL>{};
        }
        return strongPtr<U, DEL>{*this->ref_count, alias};
    }
 
    template <typename TYPE, typename DELETER>
    template <typename U, typename DEL>
    strongPtr<const U, DEL> strongPtr<TYPE, DELETER>::dynamicCastTo() const
    {
        auto alias = dynamic_cast<const U*>(this->get());
        if (alias == nullptr) {
            return strongPtr<const U, DEL>{};
        }
        return strongPtr<const U, DEL>{*this->ref_count, alias};
    }
 
    template <typename TYPE, typename DELETER>
    template <typename U, typename DEL>
    strongPtr<U, DEL> strongPtr<TYPE, DELETER>::constCastTo() const
    {
        auto alias = const_cast<U*>(this->get());
        return strongPtr<U, DEL>{*this->ref_count, alias};
    }
 
    template<typename TYPE, typename DELETER>
    void strongPtr<TYPE, DELETER>::reset() noexcept {
        this->removeStrongRef();
        this->clean();
        this->ref_count = autoPtr<TYPE, strongPtr, DELETER>::newRefCount();
        this->addStrongRef();
        this->alias_ptr = nullptr;
    }
 
    template<typename TYPE, typename DELETER>
    strongPtr<TYPE, DELETER>& strongPtr<TYPE, DELETER>::operator=(strongPtr&& other) noexcept {
        if (this == &other || *this == other)
            return *this;
 
        this->removeStrongRef();
        this->clean();
        this->ref_count = *other.ref_count;
        other.ref_count = autoPtr<TYPE, strongPtr, DELETER>::newRefCount();
        other.addStrongRef();
        this->alias_ptr = other.alias_ptr;
        return *this;
    }
 
    template<typename TYPE, typename DELETER>
    std::string strongPtr<TYPE, DELETER>::className() const {
        return "strongPtr";
    }
 
    template<typename TYPE, typename DELETER>
    strongPtr<TYPE, DELETER>::~strongPtr() {
        this->removeStrongRef();
    }
 
    template<typename T, typename DEL, typename ... Args>
    strongPtr<T, DEL> makeStrongPtr(Args &&...args) {
        return strongPtr<T, DEL>(new T(std::forward<Args>(args)...));
    }
 
    template<typename T, typename DEL, typename ... Args>
    strongPtr<T, DEL> makeStrongPtrArray(const u_integer size, Args &&...args) {
        auto strong_ptr = strongPtr<T, DEL>(new T[size]);
        for (u_integer i = 0; i < size; i++)
        {
            strong_ptr[i] = T(std::forward<Args>(args)...);
        }
        return strong_ptr;
    }
 
    template <typename TYPE, typename DELETER>
    weakPtr<TYPE, DELETER>::weakPtr(refCountBase* cnt, TYPE* alias) : weakPtr()
    {
        this->removeWeakRef();
        this->clean();
        this->ref_count = cnt;
        this->alias_ptr = alias;
        this->addWeakRef();
    }
 
    template<typename TYPE, typename DELETER>
    weakPtr<TYPE, DELETER>::weakPtr()
        : refCntPtr<TYPE, weakPtr, DELETER>() {
        this->addWeakRef();
    }
 
    template<typename TYPE, typename DELETER>
    weakPtr<TYPE, DELETER>::weakPtr(const strongPtr<TYPE, DELETER>& other)
        : weakPtr() {
        this->operator=(other);
    }
 
    template<typename TYPE, typename DELETER>
    weakPtr<TYPE, DELETER>& weakPtr<TYPE, DELETER>::operator=(const strongPtr<TYPE, DELETER>& other) {
        if (*this == other)
            return *this;
 
        this->removeWeakRef();
        this->clean();
        this->ref_count = *other.ref_count;
        this->addWeakRef();
        this->alias_ptr = other.alias_ptr;
        return *this;
    }
 
    template<typename TYPE, typename DELETER>
    weakPtr<TYPE, DELETER>::weakPtr(const weakPtr& other)
        : weakPtr() {
        this->operator=(other);
    }
 
    template<typename TYPE, typename DELETER>
    weakPtr<TYPE, DELETER>& weakPtr<TYPE, DELETER>::operator=(const weakPtr& other) {
        if (this == &other || *this == other)
            return *this;
 
        this->removeWeakRef();
        this->clean();
        this->ref_count = *other.ref_count;
        this->addWeakRef();
        this->alias_ptr = other.alias_ptr;
        return *this;
    }
 
    template<typename TYPE, typename DELETER>
    weakPtr<TYPE, DELETER>::weakPtr(weakPtr&& other) noexcept : weakPtr() {
        this->operator=(std::move(other));
    }
 
    template<typename TYPE, typename DELETER>
    weakPtr<TYPE, DELETER>& weakPtr<TYPE, DELETER>::operator=(weakPtr&& other) noexcept {
        if (this == &other || *this == other)
            return *this;
 
        this->removeWeakRef();
        this->clean();
        this->ref_count = *other.ref_count;
        other.ref_count = autoPtr<TYPE, weakPtr, DELETER>::newRefCount();
        other.addWeakRef();
        this->alias_ptr = other.alias_ptr;
        return *this;
    }
 
    template <typename TYPE, typename DELETER>
    template <typename U, typename DEL>
    weakPtr<U, DEL> weakPtr<TYPE, DELETER>::staticCastTo()
    {
        staticError<valueError, !std::is_convertible_v<TYPE*, U*>>::asserts();
        weakPtr<U, DEL> res{*this->ref_count, static_cast<U*>(this->get())};
        return res;
    }
 
    template <typename TYPE, typename DELETER>
    template <typename U, typename DEL>
    weakPtr<const U, DEL> weakPtr<TYPE, DELETER>::staticCastTo() const
    {
        staticError<valueError, !std::is_convertible_v<TYPE*, U*>>::asserts();
        weakPtr<const U, DEL> res{*this->ref_count, static_cast<const U*>(this->get())};
        return res;
    }
 
    template <typename TYPE, typename DELETER>
    template <typename U, typename DEL>
    weakPtr<U, DEL> weakPtr<TYPE, DELETER>::dynamicCastTo()
    {
        auto alias = dynamic_cast<U*>(this->get());
        if (alias == nullptr) {
            return weakPtr<U, DEL>{};
        }
        return weakPtr<U, DEL>{*this->ref_count, alias};
    }
 
    template <typename TYPE, typename DELETER>
    template <typename U, typename DEL>
    weakPtr<const U, DEL> weakPtr<TYPE, DELETER>::dynamicCastTo() const
    {
        auto alias = dynamic_cast<const U*>(this->get());
        if (alias == nullptr) {
            return weakPtr<const U, DEL>{};
        }
        return weakPtr<const U, DEL>{*this->ref_count, alias};
    }
 
    template <typename TYPE, typename DELETER>
    template <typename U, typename DEL>
    weakPtr<U, DEL> weakPtr<TYPE, DELETER>::constCastTo() const
    {
        auto alias = const_cast<U*>(this->get());
        return weakPtr<U, DEL>{*this->ref_count, alias};
    }
 
    template<typename TYPE, typename DELETER>
    strongPtr<TYPE, DELETER> weakPtr<TYPE, DELETER>::lock() const {
        strongPtr<TYPE, DELETER> strong_ptr;
        if (!this->expired()){
            strong_ptr.removeStrongRef();
            strong_ptr.clean();
            strong_ptr.ref_count = *this->ref_count;
            strong_ptr.addStrongRef();
            strong_ptr.alias_ptr = this->alias_ptr;
        }
        return strong_ptr;
    }
 
    template<typename TYPE, typename DELETER>
    const TYPE& weakPtr<TYPE, DELETER>::operator*() const {
        return this->lock().operator*();
    }
 
    template<typename TYPE, typename DELETER>
    const TYPE* weakPtr<TYPE, DELETER>::operator->() const {
        return this->lock().operator->();
    }
 
    template<typename TYPE, typename DELETER>
    const TYPE& weakPtr<TYPE, DELETER>::operator[](u_integer index) const {
        return this->lock().operator[](index);
    }
 
    template<typename TYPE, typename DELETER>
    TYPE& weakPtr<TYPE, DELETER>::operator*() {
        return this->lock().operator*();
    }
 
    template<typename TYPE, typename DELETER>
    TYPE* weakPtr<TYPE, DELETER>::operator->() {
        return this->lock().operator->();
    }
 
    template<typename TYPE, typename DELETER>
    TYPE& weakPtr<TYPE, DELETER>::operator[](u_integer index) {
        return this->lock().operator[](index);
    }
 
    template<typename TYPE, typename DELETER>
    std::string weakPtr<TYPE, DELETER>::className() const {
        return "weakPtr";
    }
 
    template<typename TYPE, typename DELETER>
    weakPtr<TYPE, DELETER>::~weakPtr() {
        this->removeWeakRef();
    }
}
 
#endif //REFCNTPTR_H