autoPtr.h

Go to the documentation of this file.

#ifndef AUTOPTR_H
#define AUTOPTR_H
 
#include "atomic.h"
#include "config.h"
#include "printable.h"
#include "comparable.h"
#include "hash.h"
#include "error.h"
 
namespace original {
    // Forward declaration for refCountBase
    class refCountBase;
 
    // Forward declaration for refCount
    template<typename TYPE, typename DELETER>
    class refCount;
 
    template<typename TYPE, typename DERIVED, typename DELETER>
    class autoPtr : public printable,
                    public comparable<autoPtr<TYPE, DERIVED, DELETER>>,
                    public hashable<autoPtr<TYPE, DERIVED, DELETER>> {
        template<typename, typename, typename> friend class autoPtr;
    protected:
        atomic<refCountBase*> ref_count; 
        TYPE* alias_ptr;         
 
        explicit autoPtr(TYPE* p);
 
        void addStrongRef() const;
 
        void addWeakRef() const;
 
        void removeStrongRef() const;
 
        void removeWeakRef() const;
 
        TYPE* releasePtr() noexcept;
 
        void destroyRefCnt() noexcept;
 
        void clean() noexcept;
 
        static refCount<TYPE, DELETER>* newRefCount(TYPE* p = nullptr);
 
    public:
 
        u_integer strongRefs() const;
 
        u_integer weakRefs() const;
 
        bool exist() const;
 
        bool expired() const;
 
        explicit operator bool() const;
 
        bool operator!() const;
 
        const TYPE* get() const;
 
        TYPE* get();
 
        virtual const TYPE& operator*() const;
 
        virtual const TYPE* operator->() const;
 
        virtual const TYPE& operator[](u_integer index) const;
 
        // Mutable accessors
        virtual TYPE& operator*();
 
        virtual TYPE* operator->();
 
        virtual TYPE& operator[](u_integer index);
 
        void swap(autoPtr& other) noexcept;
 
        integer compareTo(const autoPtr& other) const override;
 
        std::string className() const override;
 
        std::string toString(bool enter) const override;
 
        [[nodiscard]] u_integer toHash() const noexcept override;
 
        bool equals(const autoPtr& other) const noexcept override;
 
        ~autoPtr() override;
 
        template<typename T, typename DER, typename DEL>
        friend bool operator==(const autoPtr<T, DER, DEL>& ptr, const std::nullptr_t& null);
 
        template<typename T, typename DER, typename DEL>
        friend bool operator!=(const autoPtr<T, DER, DEL>& ptr, const std::nullptr_t& null);
 
        template<typename T, typename DER, typename DEL>
        friend bool operator==(const std::nullptr_t& null, const autoPtr<T, DER, DEL>& ptr);
 
        template<typename T, typename DER, typename DEL>
        friend bool operator!=(const std::nullptr_t& null, const autoPtr<T, DER, DEL>& ptr);
    };
 
    template<typename T, typename DER, typename DEL>
    bool operator==(const autoPtr<T, DER, DEL>& ptr, const std::nullptr_t& null);
 
    template<typename T, typename DER, typename DEL>
    bool operator!=(const autoPtr<T, DER, DEL>& ptr, const std::nullptr_t& null);
 
    template<typename T, typename DER, typename DEL>
    bool operator==(const std::nullptr_t& null, const autoPtr<T, DER, DEL>& ptr);
 
    template<typename T, typename DER, typename DEL>
    bool operator!=(const std::nullptr_t& null, const autoPtr<T, DER, DEL>& ptr);
 
    class refCountBase {
        template <typename, typename, typename>
        friend class autoPtr;
 
        protected:
        mutable atomic<u_integer> strong_refs; 
        mutable atomic<u_integer> weak_refs;   
 
        refCountBase();
 
        virtual const void* getPtr() const noexcept = 0;
 
        virtual void* getPtr() noexcept = 0;
 
        virtual void* releasePtr() noexcept = 0;
 
        virtual void destroyPtr() noexcept = 0;
 
        virtual ~refCountBase() = default;
    };
 
    template<typename TYPE, typename DELETER>
    class refCount final : public refCountBase {
        template <typename, typename, typename>
        friend class autoPtr;
 
        TYPE* ptr;             
        DELETER deleter;       
 
        explicit refCount(TYPE* p = nullptr);
 
        const void* getPtr() const noexcept override;
 
        void* getPtr() noexcept override;
 
        void* releasePtr() noexcept override;
 
        void destroyPtr() noexcept override;
 
        ~refCount() override;
    };
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
original::autoPtr<TYPE, DERIVED, DELETER>::autoPtr(TYPE* p)
    : ref_count(makeAtomic<refCountBase*>(newRefCount(p))), alias_ptr(nullptr) {}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::addStrongRef() const
{
    if (const refCountBase* current = *this->ref_count) {
        current->strong_refs += 1;
    }
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::addWeakRef() const
{
    if (const refCountBase* current = *this->ref_count) {
        current->weak_refs += 1;
    }
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::removeStrongRef() const
{
    if (const refCountBase* current = *this->ref_count) {
        current->strong_refs -= 1;
    }
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::removeWeakRef() const
{
    if (const refCountBase* current = *this->ref_count) {
        current->weak_refs -= 1;
    }
}
 
template <typename TYPE, typename DERIVED, typename DELETER>
TYPE* original::autoPtr<TYPE, DERIVED, DELETER>::releasePtr() noexcept
{
    refCountBase* current = *this->ref_count;
    if (!current) return nullptr;
    return static_cast<TYPE*>(current->releasePtr());
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::destroyRefCnt() noexcept {
    const refCountBase* current = *this->ref_count;
    if (!current) return;
    this->ref_count = nullptr;
    delete current;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::clean() noexcept {
    refCountBase* current = *this->ref_count;
    if (!current) {
        return;
    }
 
    const u_integer strong_refs = *current->strong_refs;
    const u_integer weak_refs = *current->weak_refs;
 
    if (strong_refs == 0) {
        current->destroyPtr();
    }
 
    if (strong_refs == 0 && weak_refs == 0) {
        this->ref_count = nullptr;
        delete current;
    }
}
 
template <typename TYPE, typename DERIVED, typename DELETER>
original::refCount<TYPE, DELETER>* original::autoPtr<TYPE, DERIVED, DELETER>::newRefCount(TYPE* p)
{
    return new refCount<TYPE, DELETER>(p);
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
original::u_integer original::autoPtr<TYPE, DERIVED, DELETER>::strongRefs() const {
    const refCountBase* current = *this->ref_count;
    if (!current) return 0;
    return *current->strong_refs;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
original::u_integer original::autoPtr<TYPE, DERIVED, DELETER>::weakRefs() const {
    const refCountBase* current = *this->ref_count;
    if (!current) return 0;
    return *current->weak_refs;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
bool original::autoPtr<TYPE, DERIVED, DELETER>::exist() const {
    const refCountBase* current = *this->ref_count;
    if (!current) return false;
    return *current->strong_refs > 0 || *current->weak_refs > 0;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
bool original::autoPtr<TYPE, DERIVED, DELETER>::expired() const {
    const refCountBase* current = *this->ref_count;
    if (!current) return true;
    return *current->strong_refs == 0;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
original::autoPtr<TYPE, DERIVED, DELETER>::operator bool() const {
    refCountBase* current = *this->ref_count;
    if (!current) return false;
    if (*current->strong_refs == 0) return false;
    const void* p = current->getPtr();
    return p != nullptr || this->alias_ptr != nullptr;
}
 
template <typename TYPE, typename DERIVED, typename DELETER>
bool original::autoPtr<TYPE, DERIVED, DELETER>::operator!() const {
    return !this->operator bool();
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
const TYPE* original::autoPtr<TYPE, DERIVED, DELETER>::get() const {
    if (!this->exist()){
        throw nullPointerError();
    }
    if (this->alias_ptr) {
        return this->alias_ptr;
    }
    refCountBase* current = *this->ref_count;
    return static_cast<TYPE*>(current->getPtr());
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
TYPE* original::autoPtr<TYPE, DERIVED, DELETER>::get() {
    if (!this->exist()){
        throw nullPointerError();
    }
    if (this->alias_ptr) {
        return this->alias_ptr;
    }
    refCountBase* current = *this->ref_count;
    return static_cast<TYPE*>(current->getPtr());
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
const TYPE& original::autoPtr<TYPE, DERIVED, DELETER>::operator*() const {
    const auto ptr = this->get();
    if (!ptr)
        throw nullPointerError();
    return *ptr;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
const TYPE*
original::autoPtr<TYPE, DERIVED, DELETER>::operator->() const {
    const auto ptr = this->get();
    if (!ptr)
        throw nullPointerError();
    return ptr;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
const TYPE& original::autoPtr<TYPE, DERIVED, DELETER>::operator[](u_integer index) const {
    const auto ptr = this->get();
    if (!ptr)
        throw nullPointerError();
    return ptr[index];
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
TYPE &original::autoPtr<TYPE, DERIVED, DELETER>::operator*() {
    auto ptr = this->get();
    if (!ptr)
        throw nullPointerError();
    return *ptr;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
TYPE*
original::autoPtr<TYPE, DERIVED, DELETER>::operator->() {
    auto ptr = this->get();
    if (!ptr)
        throw nullPointerError();
    return ptr;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
TYPE& original::autoPtr<TYPE, DERIVED, DELETER>::operator[](u_integer index) {
    auto ptr = this->get();
    if (!ptr)
        throw nullPointerError();
    return ptr[index];
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::swap(autoPtr& other) noexcept {
    std::swap(this->alias_ptr, other.alias_ptr);
 
    refCountBase* a = this->ref_count.exchange(nullptr);
    refCountBase* b = other.ref_count.exchange(a);
    this->ref_count = b;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
original::integer original::autoPtr<TYPE, DERIVED, DELETER>::compareTo(const autoPtr& other) const {
    return this->get() - other.get();
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
std::string original::autoPtr<TYPE, DERIVED, DELETER>::className() const {
    return "autoPtr";
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
std::string original::autoPtr<TYPE, DERIVED, DELETER>::toString(const bool enter) const {
    std::stringstream ss;
    ss << this->className() << "(";
    ss << formatString(this->get());
    ss << ")";
    if (enter)
        ss << "\n";
    return ss.str();
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
original::u_integer original::autoPtr<TYPE, DERIVED, DELETER>::toHash() const noexcept {
    return hash<TYPE>::hashFunc(this->get());
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
bool original::autoPtr<TYPE, DERIVED, DELETER>::equals(const autoPtr& other) const noexcept {
    return *this == other;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
original::autoPtr<TYPE, DERIVED, DELETER>::~autoPtr() {
    this->clean();
}
 
template<typename T, typename DER, typename DEL>
bool original::operator==(const autoPtr<T, DER, DEL>& ptr, const std::nullptr_t&) {
    return !ptr.operator bool();
}
 
template<typename T, typename DER, typename DEL>
bool original::operator!=(const autoPtr<T, DER, DEL>& ptr, const std::nullptr_t&) {
    return ptr.operator bool();
}
 
template<typename T, typename DER, typename DEL>
bool original::operator==(const std::nullptr_t&, const autoPtr<T, DER, DEL>& ptr) {
    return !ptr.operator bool();
}
 
template<typename T, typename DER, typename DEL>
bool original::operator!=(const std::nullptr_t&, const autoPtr<T, DER, DEL>& ptr) {
    return ptr.operator bool();
}
 
inline original::refCountBase::refCountBase() : strong_refs(makeAtomic<u_integer>(0)), weak_refs(makeAtomic<u_integer>(0)) {}
 
template<typename TYPE, typename DELETER>
original::refCount<TYPE, DELETER>::refCount(TYPE *p)
    : ptr(p) {}
 
template <typename TYPE, typename DELETER>
const void* original::refCount<TYPE, DELETER>::getPtr() const noexcept
{
    return this->ptr;
}
 
template <typename TYPE, typename DELETER>
void* original::refCount<TYPE, DELETER>::getPtr() noexcept
{
    if constexpr (std::is_const_v<TYPE>) {
        return const_cast<std::remove_const_t<TYPE>*>(this->ptr);
    } else {
        return this->ptr;
    }
}
 
template <typename TYPE, typename DELETER>
void* original::refCount<TYPE, DELETER>::releasePtr() noexcept
{
    if constexpr (std::is_const_v<TYPE>) {
        auto p = const_cast<std::remove_const_t<TYPE>*>(this->ptr);
        this->ptr = nullptr;
        return p;
    } else {
        auto p = this->ptr;
        this->ptr = nullptr;
        return p;
    }
}
 
template<typename TYPE, typename DELETER>
void original::refCount<TYPE, DELETER>::destroyPtr() noexcept {
    TYPE* tmp = this->ptr;
    this->ptr = nullptr;
    this->deleter(tmp);
}
 
template<typename TYPE, typename DELETER>
original::refCount<TYPE, DELETER>::~refCount() {
    this->destroyPtr();
}
 
#endif //AUTOPTR_H