autoPtr.h

Go to the documentation of this file.

#ifndef AUTOPTR_H
#define AUTOPTR_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:
        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 u_integer strong_refs; 
        mutable 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(newRefCount(p)), alias_ptr(nullptr) {}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::addStrongRef() const
{
    this->ref_count->strong_refs += 1;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::addWeakRef() const
{
    this->ref_count->weak_refs += 1;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::removeStrongRef() const
{
    this->ref_count->strong_refs -= 1;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::removeWeakRef() const
{
    this->ref_count->weak_refs -= 1;
}
 
template <typename TYPE, typename DERIVED, typename DELETER>
TYPE* original::autoPtr<TYPE, DERIVED, DELETER>::releasePtr() noexcept
{
    return static_cast<TYPE*>(this->ref_count->releasePtr());
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::destroyRefCnt() noexcept {
    delete this->ref_count;
    this->ref_count = nullptr;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::clean() noexcept {
    if (!this->exist()){
        this->destroyRefCnt();
    }
    if (this->expired()){
        this->ref_count->destroyPtr();
    }
}
 
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 {
    return this->ref_count->strong_refs;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
original::u_integer original::autoPtr<TYPE, DERIVED, DELETER>::weakRefs() const {
    return this->ref_count->weak_refs;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
bool original::autoPtr<TYPE, DERIVED, DELETER>::exist() const {
    return this->ref_count && (this->strongRefs() > 0 || this->weakRefs() > 0);
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
bool original::autoPtr<TYPE, DERIVED, DELETER>::expired() const {
    return this->ref_count && this->strongRefs() == 0;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
original::autoPtr<TYPE, DERIVED, DELETER>::operator bool() const {
    return this->exist() && this->get();
}
 
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;
    }
    return static_cast<TYPE*>(this->ref_count->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;
    }
    return static_cast<TYPE*>(this->ref_count->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 {
    auto other_ref_count = other.ref_count;
    other.ref_count = this->ref_count;
    this->ref_count = other_ref_count;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
original::integer original::autoPtr<TYPE, DERIVED, DELETER>::compareTo(const autoPtr& other) const {
    return this->ref_count - other.ref_count;
}
 
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(0), weak_refs(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