ZFCorePointer.h

Go to the documentation of this file.

#ifndef _ZFI_ZFCorePointer_h_
#define _ZFI_ZFCorePointer_h_
 
#include "ZFCoreTypeDef.h"
#include "ZFCoreUtilMacro.h"
#include "zfstr.h"
 
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
template<typename T_Pointer>
zfclassNotPOD _ZFP_ZFCorePointerHelper;
template<typename T_Pointer>
zfclassNotPOD _ZFP_ZFCorePointerHelper<T_Pointer *> {
public:
    static inline void *toNonConstRaw(ZF_IN T_Pointer *p) {
        return p;
    }
    template<typename T_ZFCorePointer>
    static inline T_Pointer *toPointer(ZF_IN T_ZFCorePointer p) {
        return (T_Pointer *)p->pointerValueAccessNonConst();
    }
};
template<typename T_Pointer>
zfclassNotPOD _ZFP_ZFCorePointerHelper<const T_Pointer *> {
public:
    static inline void *toNonConstRaw(ZF_IN const T_Pointer *p) {
        return zfnull;
    }
    template<typename T_ZFCorePointer>
    static inline const T_Pointer *toPointer(ZF_IN T_ZFCorePointer p) {
        return (const T_Pointer *)p->pointerValueAccess();
    }
};
 
// ============================================================
zfclassLikePOD ZFLIB_ZFCore ZFCorePointer {
    ZFCLASS_DISALLOW_COPY_CONSTRUCTOR(ZFCorePointer)
public:
    ZFCorePointer(void) {}
    virtual ~ZFCorePointer(void) {}
 
public:
    virtual void objectInfoT(ZF_IN_OUT zfstring &ret) const {
        if(this->pointerValueAccess() == zfnull) {
            ret += ZFTOKEN_zfnull;
        }
        else {
            this->objectInfoOfContentT(ret);
        }
    }

    virtual inline zfstring objectInfo(void) const {
        zfstring ret;
        this->objectInfoT(ret);
        return ret;
    }
 
public:
    virtual void objectInfoOfContentT(ZF_IN_OUT zfstring &ret) const zfpurevirtual;
    virtual inline zfstring objectInfoOfContent(void) const {
        zfstring ret;
        this->objectInfoOfContentT(ret);
        return ret;
    }
 
public:
    virtual ZFCompareResult objectCompare(ZF_IN const ZFCorePointer &another) const {
        return ((this->pointerValueAccess() == another.pointerValueAccess())
            ? ZFCompareEqual
            : ZFCompareUncomparable);
    }
 
public:
    virtual const ZFCorePointer *refNew(void) const zfpurevirtual;
    virtual void refDelete(void) const {
        zfdelete(const_cast<ZFCorePointer *>(this));
    }

    virtual const void *pointerValueAccess(void) const zfpurevirtual;
    virtual void *pointerValueAccessNonConst(void) const zfpurevirtual;

    template<typename T_PointerDesired>
    inline T_PointerDesired pointerValueT(void) const {
        return _ZFP_ZFCorePointerHelper<T_PointerDesired>::toPointer(this);
    }

    virtual zfindex objectRetainCount(void) const zfpurevirtual;
};
ZFOUTPUT_TYPE(ZFCorePointer, {v.objectInfoT(s);})
 
// ============================================================
template<typename T_Pointer>
zfclassNotPOD _ZFP_ZFCorePointerPrivate {
public:
    zfuint refCount;
    T_Pointer pointerValue;
public:
    _ZFP_ZFCorePointerPrivate(void)
    : refCount(1)
    , pointerValue(zfnull)
    {
    }
};
template<typename T_Pointer, typename T_ZFCorePointerType>
zffinal zfclassLikePOD ZFCorePointerT : zfextend ZFCorePointer {
public:
    inline void pointerValue(ZF_IN T_Pointer const &value) {
        if(d->pointerValue != value) {
            T_Pointer pointerValueOld = d->pointerValue;
            d->pointerValue = value;
            if(value) {
                T_ZFCorePointerType::pointerOnRetain(d->pointerValue);
            }
            if(pointerValueOld != zfnull) {
                T_ZFCorePointerType::pointerOnDelete(pointerValueOld);
            }
        }
    }

    inline T_Pointer const &pointerValue(void) const {
        return d->pointerValue;
    }
 
public:
    inline T_Pointer operator -> (void) const {
        return d->pointerValue;
    }
    inline zfbool operator == (ZF_IN zfnullT const &p) const {
        return (d->pointerValue == zfnull);
    }
    inline zfbool operator != (ZF_IN zfnullT const &p) const {
        return (d->pointerValue != zfnull);
    }
    inline zfbool operator == (ZF_IN T_Pointer const &p) const {
        return (d->pointerValue == p);
    }
    inline zfbool operator != (ZF_IN T_Pointer const &p) const {
        return (d->pointerValue != p);
    }
    inline zfbool operator == (ZF_IN ZFCorePointerT<T_Pointer, T_ZFCorePointerType> const &ref) const {
        return (d->pointerValue == ref.d->pointerValue);
    }
    inline zfbool operator != (ZF_IN ZFCorePointerT<T_Pointer, T_ZFCorePointerType> const &ref) const {
        return (d->pointerValue == ref.d->pointerValue);
    }
 
public:
    ZFCorePointerT(void)
    : d(zfnew(_ZFP_ZFCorePointerPrivate<T_Pointer>))
    {
    }
    ZFCorePointerT(ZF_IN zfnullT const &value)
    : d(zfnew(_ZFP_ZFCorePointerPrivate<T_Pointer>))
    {
    }
    ZFCorePointerT(ZF_IN T_Pointer const &value)
    : d(zfnew(_ZFP_ZFCorePointerPrivate<T_Pointer>))
    {
        this->pointerValue(value);
    }
    ZFCorePointerT(ZF_IN const ZFCorePointerT<T_Pointer, T_ZFCorePointerType> &ref)
    : d(ref.d)
    {
        ++(d->refCount);
    }
    virtual ~ZFCorePointerT(void) {
        --(d->refCount);
        if(d->refCount == 0) {
            if(d->pointerValue != zfnull) {
                T_ZFCorePointerType::pointerOnDelete(d->pointerValue);
            }
            zfdelete(d);
        }
    }
    ZFCorePointerT<T_Pointer, T_ZFCorePointerType> &operator = (ZF_IN const ZFCorePointerT<T_Pointer, T_ZFCorePointerType> &ref) {
        _ZFP_ZFCorePointerPrivate<T_Pointer> *dTmp = d;
        d = ref.d;
        ++(ref.d->refCount);
        --(dTmp->refCount);
        if(dTmp->refCount == 0) {
            if(dTmp->pointerValue != zfnull) {
                T_ZFCorePointerType::pointerOnDelete(dTmp->pointerValue);
            }
            zfdelete(dTmp);
        }
        return *this;
    }
    ZFCorePointerT<T_Pointer, T_ZFCorePointerType> &operator = (ZF_IN T_Pointer const &value) {
        this->pointerValue(value);
        return *this;
    }
    operator T_Pointer (void) const {
        return d->pointerValue;
    }
 
public:
    zfoverride
    virtual void objectInfoOfContentT(ZF_IN_OUT zfstring &ret) const {
        this->objectInfoOfContentT(ret, zfnull);
    }

    virtual void objectInfoOfContentT(
            ZF_IN_OUT zfstring &ret
            , ZF_IN typename ZFCoreInfoGetter<T_Pointer>::InfoGetter infoGetter
            ) const {
        if(infoGetter != zfnull) {
            infoGetter(ret, d->pointerValue);
        }
        else {
            zftToStringT(ret, d->pointerValue);
        }
    }
 
public:
    zfoverride
    virtual const ZFCorePointer *refNew(void) const {
        return zfnew((ZFCorePointerT<T_Pointer, T_ZFCorePointerType>), *this);
    }
    zfoverride
    virtual inline const void *pointerValueAccess(void) const {
        return d->pointerValue;
    }
    zfoverride
    virtual inline void *pointerValueAccessNonConst(void) const {
        return _ZFP_ZFCorePointerHelper<T_Pointer>::toNonConstRaw(d->pointerValue);
    }
 
    zfoverride
    virtual zfindex objectRetainCount(void) const {
        return d->refCount;
    }

    template<typename T_PointerDesired>
    inline T_PointerDesired pointerValueT(void) const {
        return _ZFP_ZFCorePointerHelper<T_PointerDesired>::toPointer(this);
    }
 
private:
    _ZFP_ZFCorePointerPrivate<T_Pointer> *d;
};
ZFOUTPUT_TYPE_TEMPLATE(ZFM_EXPAND(typename T_Pointer, typename T_ZFCorePointerType), ZFM_EXPAND(ZFCorePointerT<T_Pointer, T_ZFCorePointerType>), {v.objectInfoT(s);})
 
// ============================================================
#define ZFCOREPOINTER_DECLARE(T_ZFCorePointer, pointerRetainAction, pointerDeleteAction) \
    template<typename T_Pointer> \
    zfclassNotPOD _ZFP_CPT_##T_ZFCorePointer { \
    public: \
        static inline void pointerOnRetain(T_Pointer const &p) \
        pointerRetainAction \
        static inline void pointerOnDelete(T_Pointer const &p) \
        pointerDeleteAction \
    }; \ \
    template<typename T_Pointer> \
    zfclassLikePOD T_ZFCorePointer : zfextend ZFCorePointerT<T_Pointer, _ZFP_CPT_##T_ZFCorePointer<T_Pointer> > { \
    public: \ \
        T_ZFCorePointer(void) \
        : ZFCorePointerT<T_Pointer, _ZFP_CPT_##T_ZFCorePointer<T_Pointer> >() \
        { \
        } \
        T_ZFCorePointer(ZF_IN T_Pointer const &value) \
        : ZFCorePointerT<T_Pointer, _ZFP_CPT_##T_ZFCorePointer<T_Pointer> >(value) \
        { \
        } \
        T_ZFCorePointer(ZF_IN zfnullT const &value) \
        : ZFCorePointerT<T_Pointer, _ZFP_CPT_##T_ZFCorePointer<T_Pointer> >() \
        { \
        } \
        T_ZFCorePointer(ZF_IN ZFCorePointerT<T_Pointer, _ZFP_CPT_##T_ZFCorePointer<T_Pointer> > const &ref) \
        : ZFCorePointerT<T_Pointer, _ZFP_CPT_##T_ZFCorePointer<T_Pointer> >(ref) \
        { \
        } \
        T_ZFCorePointer<T_Pointer> &operator = (ZF_IN T_Pointer const &value) { \
            ZFCorePointerT<T_Pointer, _ZFP_CPT_##T_ZFCorePointer<T_Pointer> >::operator = (value); \
            return *this; \
        } \
        T_ZFCorePointer<T_Pointer> &operator = (ZF_IN ZFCorePointerT<T_Pointer, _ZFP_CPT_##T_ZFCorePointer<T_Pointer> > const &ref) { \
            ZFCorePointerT<T_Pointer, _ZFP_CPT_##T_ZFCorePointer<T_Pointer> >::operator = (ref); \
            return *this; \
        } \
        template<typename T_PointerDesired> \
        inline T_PointerDesired pointerValueT(void) const { \
            return _ZFP_ZFCorePointerHelper<T_PointerDesired>::toPointer(this); \
        } \
        inline T_Pointer operator -> (void) const { \
            return this->pointerValue(); \
        } \
        template<typename T_Ref> \
        inline T_Ref operator * (void) const { \
            return *(this->pointerValue()); \
        } \
        inline zfbool operator == (ZF_IN zfnullT const &p) const { \
            return (this->pointerValue() == zfnull); \
        } \
        inline zfbool operator != (ZF_IN zfnullT const &p) const { \
            return (this->pointerValue() != zfnull); \
        } \
        inline zfbool operator == (ZF_IN T_Pointer const &p) const { \
            return (this->pointerValue() == p); \
        } \
        inline zfbool operator != (ZF_IN T_Pointer const &p) const { \
            return (this->pointerValue() != p); \
        } \
        inline zfbool operator == (ZF_IN T_ZFCorePointer<T_Pointer> const &ref) const { \
            return (this->pointerValue() == ref.pointerValue()); \
        } \
        inline zfbool operator != (ZF_IN T_ZFCorePointer<T_Pointer> const &ref) const { \
            return (this->pointerValue() == ref.pointerValue()); \
        } \ \
    }; \
    ZFOUTPUT_TYPE_TEMPLATE(typename T_Pointer, T_ZFCorePointer<T_Pointer>, {v.objectInfoT(s);})
 
ZFCOREPOINTER_DECLARE(ZFCorePointerForPointerRef, {}, {})
ZFCOREPOINTER_DECLARE(ZFCorePointerForPOD, {}, {zffree(p);})
ZFCOREPOINTER_DECLARE(ZFCorePointerForObject, {}, {zfdelete(p);})
ZFCOREPOINTER_DECLARE(ZFCorePointerForPoolObject, {}, {zfpoolDelete(p);})
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFCorePointer_h_