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 friend class
    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>> {
    protected:
        refCount<TYPE, DELETER>* ref_count; 

        explicit autoPtr(TYPE* p);

        void setPtr(TYPE* p);

        void addStrongRef();

        void addWeakRef();

        void removeStrongRef();

        void removeWeakRef();

        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);

    template<typename TYPE, typename DELETER>
    class refCount {
        template <typename, typename, typename>
        friend class autoPtr;
 
        TYPE* ptr;             
        u_integer strong_refs; 
        u_integer weak_refs;   
        DELETER deleter;       

        explicit refCount(TYPE* p = nullptr);

        void destroyPtr() noexcept;

        ~refCount();
    };
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
original::autoPtr<TYPE, DERIVED, DELETER>::autoPtr(TYPE* p)
    : ref_count(newRefCount(p)) {}
 
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::setPtr(TYPE* p) {
    if (!this->exist()){
        throw nullPointerError();
    }
    this->ref_count->ptr = p;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::addStrongRef() {
    this->ref_count->strong_refs += 1;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::addWeakRef() {
    this->ref_count->weak_refs += 1;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::removeStrongRef() {
    this->ref_count->strong_refs -= 1;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
void original::autoPtr<TYPE, DERIVED, DELETER>::removeWeakRef() {
    this->ref_count->weak_refs -= 1;
}
 
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();
    }
    return this->ref_count->ptr;
}
 
template<typename TYPE, typename DERIVED, typename DELETER>
TYPE* original::autoPtr<TYPE, DERIVED, DELETER>::get() {
    if (!this->exist()){
        throw nullPointerError();
    }
    return this->ref_count->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->() 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();
}
 
template<typename TYPE, typename DELETER>
original::refCount<TYPE, DELETER>::refCount(TYPE *p)
    : ptr(p), strong_refs(0), weak_refs(0) {}
 
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