d_ptr.h

Go to the documentation of this file.

 
#ifndef  BASE_D_POINTER_H
#define  BASE_D_POINTER_H
 
namespace A_UTILS_NS
{
    template <class _PARENT, class _PRIVATE_D>
    class d_ptr_impl
    {
    protected:
        _PARENT* _p = nullptr;
 
    public:
        d_ptr_impl() = default;
 
        virtual ~d_ptr_impl()
        {
            Release_d();
            _p = nullptr;
        }
 
        d_ptr_impl(const d_ptr_impl&) = delete;
        d_ptr_impl& operator=(const d_ptr_impl&) = delete;
 
        d_ptr_impl(d_ptr_impl&&) = delete;
        d_ptr_impl& operator=(d_ptr_impl&&) = delete;
 
        tVoid Set_p(_PARENT* _pInst)
        {
            _p = _pInst;
            Create_d();
        }
 
        inline _PRIVATE_D* operator->() const
        {
            return (_PRIVATE_D*)(this);
        }
 
        inline _PRIVATE_D* Get_d() const
        {
            return (_PRIVATE_D*)(this);
        }
 
        inline operator _PRIVATE_D*() const
        {
            return (_PRIVATE_D*)(this);
        }
 
        operator d_ptr_impl<_PARENT, _PRIVATE_D>*() const
        {
            return (d_ptr_impl< _PARENT, _PRIVATE_D >*)(&*this);
        }
 
    protected:
        virtual tVoid Create_d()
        {
            //nothing to do this is to overwrite
        }
        virtual tVoid Release_d()
        {
            //nothing to do this is to overwrite
        }
    };
 
    template <class _PARENT, class _PRIVATE_D>
    class d_ptr
    {
    private:
        typedef d_ptr_impl<_PARENT, _PRIVATE_D> internal_type;    
 
    protected:
        internal_type* _dRef = nullptr;
 
    public:
        typedef d_ptr<_PARENT, _PRIVATE_D> self_type;     
 
        d_ptr() = default;
 
        virtual ~d_ptr()
        {
            if (_dRef)
            {
                delete _dRef;
                _dRef = nullptr;
            }
        }
 
        //No copying allowed - this is no shared ptr!
        d_ptr(const d_ptr&) = delete;
        d_ptr& operator=(const d_ptr&) = delete;
 
        //moving allowed
        d_ptr(d_ptr&& o_oOther) : _dRef(nullptr)
        {   //leave move-from-object in valid but unspecified state
            Swap(o_oOther);
        }
 
        d_ptr& operator=(d_ptr&& o_oOther)
        {   //leave move-from-object in valid but unspecified state
            if (this != &o_oOther)
            {
                Swap(o_oOther);
                //Reset move-from-object
                self_type().Swap(o_oOther);
            }
            return *this;
        }
 
        tVoid Set_p(_PARENT* _pInst)
        {
            if (_dRef)
            {
                _dRef->Set_p(_pInst);
            }
        }
 
        _PRIVATE_D* operator->() const
        {
            return Get_d();
        }
 
        _PRIVATE_D* Get_d() const
        {
            return (_PRIVATE_D*)(_dRef);
        }
 
        operator _PRIVATE_D*() const
        {
            return Get_d();
        }
 
        self_type* operator=(_PRIVATE_D* _dInst)
        {
            if (_dRef)
            {
                delete _dRef;
            }
            _dRef = (internal_type*)_dInst;
            return this;
        }
 
        tVoid Swap(self_type& o_oOther)
        {   //std::swap not present, do it yourself...
            const auto _dRefTmp = _dRef;
            _dRef = o_oOther._dRef;
            o_oOther._dRef = _dRefTmp;
        }
    };//class class cAUTILSDPtr
} //namespace
 
namespace std
{
    template<typename _PARENT, typename _PRIVATE_D>
    inline tVoid swap(A_UTILS_NS::d_ptr<_PARENT, _PRIVATE_D>& i_oLHS,
        A_UTILS_NS::d_ptr<_PARENT, _PRIVATE_D>& i_oRHS)
    {
        i_oLHS.Swap(i_oRHS);
    }
}//ns std
 
 
#define A_UTILS_D_CLASS(__dclassname_, __pclassname_) \
private: \
   class __dclassname_; \
   A_UTILS_NS::d_ptr<__pclassname_, __dclassname_> _d; \
   friend class __dclassname_;
 
#define A_UTILS_D(__pclassname_)  A_UTILS_D_CLASS(__pclassname_ ## Private, __pclassname_)
 
#define A_UTILS_D_CREATE_CLASS(__classname_) \
    _d = new __classname_(); \
    _d->Set_p(this)
 
#define A_UTILS_D_CREATE(__classname_)  A_UTILS_D_CREATE_CLASS(__classname_ ## Private)
 
#define A_UTILS_DECLARE_LOCAL_D(__classname_)  __classname_ ## Private* _D = _d.Get_d()
 
#define A_UTILS_P_DECLARE_CLASS(__d_classname_, __p_classname_) class __p_classname_::__d_classname_ : public A_UTILS_NS::d_ptr_impl<__p_classname_, __p_classname_::__d_classname_>
 
#define A_UTILS_P_DECLARE( __p_classname_) A_UTILS_P_DECLARE_CLASS(__p_classname_ ## Private, __p_classname_)
 
#define A_UTILS_P_CLASS( __p_classname_)  __p_classname_::__p_classname_ ## Private
 
#define A_UTILS_P_DECLARE_CLASS_PRE(__d_classname_, __p_classname_) \
    A_UTILS_P_DECLARE_CLASS(__d_classname_, __p_classname_)\
    { \
        friend class __p_classname_; \
        public: \
            __d_classname_(){}; \
            virtual ~__d_classname_(){}; \
    };
 
#define A_UTILS_P_DECLARE_PRE(__p_classname_) A_UTILS_P_DECLARE_CLASS_PRE(__p_classname_ ## Private, __p_classname_)
 
#endif /* BASE_D_POINTER_H */