SmartPointer.hpp

#pragma once

#include <map>
#include <mutex>

namespace samchon
{
    template<typename _Ty> 
    class SmartPointer
    {
    private:
        static std::map<_Ty*, size_t> useCountMap;

        static std::mutex mtx;

    private:
        _Ty* ptr;

    public:
        /* --------------------------------------------------------------
            CONSTRUCTORS
        -------------------------------------------------------------- */
        SmartPointer()
        {
            ptr = nullptr;
        };

        explicit SmartPointer(const _Ty* ptr)
            : SmartPointer()
        {
            reset(ptr);
        };

        SmartPointer(const SmartPointer &smartPointer)
            : SmartPointer(smartPointer.ptr) {};

        SmartPointer(SmartPointer &&smartPointer)
        {
            ptr = smartPointer.ptr;
            smartPointer.ptr = nullptr;
        }

        ~SmartPointer()
        {
            std::lock_guard<std::mutex> lockGuard(mtx);
            destruct(ptr);
        };

    public:
        /* --------------------------------------------------------------
            SETTERS
        -------------------------------------------------------------- */
        void reset(const _Ty* ptr)
        {
            std::lock_guard<std::mutex> lockGuard(mtx);
            if (this->ptr == ptr)
                return;

            construct((_Ty*)ptr);
            destruct(this->ptr);

            this->ptr = (_Ty*)ptr;
        };

        /* --------------------------------------------------------------
            GETTERS
        -------------------------------------------------------------- */
        inline auto get() const -> _Ty*
        {
            return ptr;
        };

        auto operator->() const -> _Ty*
        {
            return get();
        };

        auto operator*() const -> _Ty&
        {
            return *get();
        };

        /* --------------------------------------------------------------
            STATISTICS
        -------------------------------------------------------------- */
    private:
        static void construct(_Ty *ptr)
        {
            if (ptr == nullptr)
                return;

            if (useCountMap.find(ptr) != useCountMap.end())
                useCountMap[ptr]++;
            else
                useCountMap[ptr] = 1;
        }
        static void destruct(_Ty *ptr)
        {
            if (ptr == nullptr)
                return;

            if (useCountMap.find(ptr) != useCountMap.end())
                if (--useCountMap[ptr] == 0)
                {
                    useCountMap.erase(ptr);
                    delete ptr;
                }
        };
    };

    template<typename _Ty> std::map<_Ty*, size_t> SmartPointer<_Ty>::useCountMap;
    template<typename _Ty> std::mutex SmartPointer<_Ty>::mtx;
};