ZFValue.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFValue_h_
#define _ZFI_ZFValue_h_
 
#include "ZFObjectCore.h"
#include "ZFObjectRetain.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
zfclassNotPOD ZFLIB_ZFCore _ZFP_ZFValueType {
public:
    static void TypePOD(ZF_IN void *value) {
        zffree(value);
    }
    template<typename T_Object>
    static void TypeObject(ZF_IN void *value) {
        zfdelete((T_Object *)value);
    }
    template<typename T_Object>
    static void TypePoolObject(ZF_IN void *value) {
        zfpoolDelete((T_Object *)value);
    }
};
#define ZFValueTypePointerRef() zfnull
#define ZFValueTypePOD() _ZFP_ZFValueType::TypePOD
#define ZFValueTypeObject(T_Object) _ZFP_ZFValueType::TypeObject<T_Object >
#define ZFValueTypePoolObject(T_Object) _ZFP_ZFValueType::TypePoolObject<T_Object >
 
// ============================================================
// ZFValue
zfclassFwd ZFValue;
typedef void (*ZFValueType)(ZF_IN void *value);

zffinal zfclass ZFLIB_ZFCore ZFValue : zfextend ZFObject {
    // ============================================================
public:
    ZFOBJECT_DECLARE_WITH_CUSTOM_CTOR(ZFValue, ZFObject)
 
protected:
    ZFValue(void) : _value(zfnull), _type(zfnull) {}
 
    ZFOBJECT_CACHE_RELEASE({
        cache->_cleanup();
    })
private:
    void *_value;
    ZFValueType _type;
    void _cleanup(void) {
        if(_value && _type) {
            void *value = _value;
            ZFValueType type = _type;
            _value = zfnull;
            _type = zfnull;
            type(value);
        }
        else {
            _value = zfnull;
            _type = zfnull;
        }
    }
 
protected:
    virtual void objectOnInit(
        ZF_IN void *value
        , ZF_IN ZFValueType type
        ) {
        _value = value;
        _type = type;
    }

    template<typename T_Value>
    void objectOnInit(ZF_IN T_Value const &value) {
        _value = zfpoolNew(T_Value, value);
        _type = ZFValueTypePoolObject(T_Value);
    }
    zfoverride
    virtual void objectOnInit(void) {
        zfsuper::objectOnInit();
    }
    zfoverride
    virtual void objectOnDeallocPrepare(void) {
        this->_cleanup();
        zfsuper::objectOnDeallocPrepare();
    }
 
public:
    ZFValue *value(ZF_IN void *value, ZF_IN ZFValueType type) {
        if(_value && _type) {
            void *valueOld = _value;
            ZFValueType typeOld = _type;
            _value = value;
            _type = type;
            typeOld(valueOld);
        }
        else {
            _value = value;
            _type = type;
        }
        return this;
    }

    template<typename T_Value>
    ZFValue *value(ZF_IN T_Value const &value) {
        if(_value && _type) {
            void *valueOld = _value;
            ZFValueType typeOld = _type;
            _value = zfpoolNew(T_Value, value);
            _type = ZFValueTypePoolObject(T_Value);
            typeOld(valueOld);
        }
        else {
            _value = zfpoolNew(T_Value, value);
            _type = ZFValueTypePoolObject(T_Value);
        }
        return this;
    }
 
public:
    zfbool valid(void) {return _value != zfnull;}
    void *valuePtr(void) {return _value;}
    ZFValueType type(void) {return _type;}
 
public:
    template<typename T_Value>
    inline T_Value &value(void) {
        return *(T_Value *)_value;
    }

    template<typename T_Value>
    inline T_Value *valuePtr(void) {
        return (T_Value *)_value;
    }
 
protected:
    zfoverride
    virtual void objectInfoImplAppend(ZF_IN_OUT zfstring &ret);
public:
    zfoverride
    virtual ZFCompareResult objectCompareValueImpl(ZF_IN ZFObject *anotherObj);
};
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFValue_h_