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;
        }
        virtual ~d_ptr_impl() {…}

        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();
        }
        tVoid Set_p(_PARENT* _pInst) {…}

        inline _PRIVATE_D* operator->() const
        {
            return (_PRIVATE_D*)(this);
        }
        inline _PRIVATE_D* operator->() const {…}

        inline _PRIVATE_D* Get_d() const
        {
            return (_PRIVATE_D*)(this);
        }
        inline _PRIVATE_D* Get_d() const {…}

        inline operator _PRIVATE_D*() const
        {
            return (_PRIVATE_D*)(this);
        }
        inline operator _PRIVATE_D*() const {…}

        operator d_ptr_impl<_PARENT, _PRIVATE_D>*() const
        {
            return (d_ptr_impl< _PARENT, _PRIVATE_D >*)(&*this);
        }
        operator d_ptr_impl<_PARENT, _PRIVATE_D>*() const {…}
 
    protected:
        virtual tVoid Create_d()
        {
            //nothing to do this is to overwrite
        }
        virtual tVoid Create_d() {…}

        virtual tVoid Release_d()
        {
            //nothing to do this is to overwrite
        }
        virtual tVoid Release_d() {…}
    };
    class d_ptr_impl {…};

    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;
            }
        }
        virtual ~d_ptr() {…}
 
        //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);
            }
        }
        tVoid Set_p(_PARENT* _pInst) {…}

        _PRIVATE_D* operator->() const
        {
            return Get_d();
        }
        _PRIVATE_D* operator->() const {…}

        _PRIVATE_D* Get_d() const
        {
            return (_PRIVATE_D*)(_dRef);
        }
        _PRIVATE_D* Get_d() const {…}

        operator _PRIVATE_D*() const
        {
            return Get_d();
        }
        operator _PRIVATE_D*() const {…}

        self_type* operator=(_PRIVATE_D* _dInst)
        {
            if (_dRef)
            {
                delete _dRef;
            }
            _dRef = (internal_type*)_dInst;
            return this;
        }
        self_type* operator=(_PRIVATE_D* _dInst) {…}

        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;
        }
        tVoid Swap(self_type& o_oOther) {…}
    };//class class cAUTILSDPtr
    class d_ptr {…};
} //namespace
namespace A_UTILS_NS {…}
 
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);
    }
    inline tVoid swap(A_UTILS_NS::d_ptr<_PARENT, _PRIVATE_D>& i_oLHS, {…}
}//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_CLASS(__dclassname_, __pclassname_) \ …

#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_CLASS(__classname_) \ …

#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_CLASS_PRE(__d_classname_, __p_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 */