SharedPtr.hpp

Go to the documentation of this file.

#pragma once

#include <vector>
#include <mutex>
#include <ememory/debug.hpp>
#include <ememory/Counter.hpp>
#include <ememory/EnableSharedFromThis.hpp>

namespace ememory {
    template<typename> class WeakPtr;
    template<typename> class EnableSharedFromThis;
    using deleterCall = std::function<void(void* _data)>;
    template<typename EMEMORY_TYPE>
    class SharedPtr {
        friend class WeakPtr<EMEMORY_TYPE>;
        private:
            EMEMORY_TYPE* m_element; 
            ememory::Counter* m_counter; 
            deleterCall m_deleter; 

            deleterCall createDeleter() const {
                return [](void* _data) { delete((EMEMORY_TYPE*)_data);};
            }
        public:
            #ifndef PARSE_DOXYGEN
                template<class EMEMORY_TYPE2,
                         typename std::enable_if<    std::is_same<EMEMORY_TYPE2, EMEMORY_TYPE>::value
                                                  && std::is_base_of<ememory::EnableSharedFromThisBase, EMEMORY_TYPE2>::value
                                                 , int>::type = 0>
                SharedPtr(EMEMORY_TYPE2* _element);
                template<class EMEMORY_TYPE2,
                         typename std::enable_if<    std::is_same<EMEMORY_TYPE2, EMEMORY_TYPE>::value
                                                  && !std::is_base_of<ememory::EnableSharedFromThisBase, EMEMORY_TYPE2>::value
                                                 , int>::type = 0>
                SharedPtr(EMEMORY_TYPE2* _element);
            #else

                SharedPtr(EMEMORY_TYPE2* _element);
            #endif
        public:
            SharedPtr(std::nullptr_t);
            SharedPtr();
            SharedPtr(EMEMORY_TYPE* _obj, ememory::Counter* _counter);
            SharedPtr(const SharedPtr<EMEMORY_TYPE>& _obj);
            SharedPtr(SharedPtr<EMEMORY_TYPE>&& _obj);
            ~SharedPtr();
            SharedPtr& operator= (const SharedPtr<EMEMORY_TYPE>& _obj);
            SharedPtr& operator= (std::nullptr_t);
        public:
            #ifndef PARSE_DOXYGEN
                template<class EMEMORY_TYPE2,
                         typename std::enable_if<  std::is_base_of<EMEMORY_TYPE, EMEMORY_TYPE2>::value
                                                 , int>::type = 0>
                SharedPtr(const SharedPtr<EMEMORY_TYPE2>& _obj);
                template<class EMEMORY_TYPE2,
                         typename std::enable_if<  std::is_base_of<EMEMORY_TYPE, EMEMORY_TYPE2>::value
                                                 , int>::type = 0>
                SharedPtr& operator= (const SharedPtr<EMEMORY_TYPE2>& _obj);
            #endif
        public:
            void reset();
            int64_t useCount() const;
            bool operator==(std::nullptr_t) const;
            template<class EMEMORY_TYPE2>
            bool operator==(const SharedPtr<EMEMORY_TYPE2>& _obj) const;
            bool operator!=(std::nullptr_t) const;
            template<class EMEMORY_TYPE2>
            bool operator!=(const SharedPtr<EMEMORY_TYPE2>& _obj) const;
            const EMEMORY_TYPE* get() const;
            EMEMORY_TYPE* get();
            const EMEMORY_TYPE* operator->() const;
            EMEMORY_TYPE* operator->();
            const EMEMORY_TYPE& operator*() const;
            EMEMORY_TYPE& operator*();
            void swap(SharedPtr<EMEMORY_TYPE>& _obj);
            ememory::Counter* getCounter() const {
                return m_counter;
            }
            deleterCall getDeleter() const {
                return m_deleter;
            }
            // TODO: unique
            // TODO: bool
    };
}

#include <ememory/details/SharedPtr.hxx>