ZFCoreOrderMap.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFCoreOrderMap_h_
#define _ZFI_ZFCoreOrderMap_h_
 
#include "ZFCorePointer.h"
#include "ZFCoreArray.h"
#include "zfiter.h"
#include "ZFToken.h"
 
ZF_NAMESPACE_GLOBAL_BEGIN
 
zfclassFwd _ZFP_ZFCoreOrderMapPrivate;
zffinal zfclassLikePOD ZFLIB_ZFCore ZFCoreOrderMap {
public:
    ZFCoreOrderMap(void);
    ZFCoreOrderMap(ZF_IN const ZFCoreOrderMap &ref);
    zffinal ZFCoreOrderMap &operator = (ZF_IN const ZFCoreOrderMap &ref);
    zffinal zfbool operator == (ZF_IN const ZFCoreOrderMap &ref) const;
    zffinal zfbool operator != (ZF_IN const ZFCoreOrderMap &ref) const {return !this->operator == (ref);}
    ~ZFCoreOrderMap(void);
 
public:
    zffinal void objectInfoT(ZF_IN_OUT zfstring &ret) const;
    zffinal zfstring objectInfo(void) const {
        zfstring ret;
        this->objectInfoT(ret);
        return ret;
    }
 
public:
    zffinal void objectInfoOfContentT(
            ZF_IN_OUT zfstring &ret
            , ZF_IN_OPT zfindex maxCount = zfindexMax()
            , ZF_IN_OPT const ZFTokenForKeyValueContainer &token = ZFTokenForKeyValueContainerDefault()
            ) const;
    zffinal zfstring objectInfoOfContent(
            ZF_IN_OPT zfindex maxCount = zfindexMax()
            , ZF_IN_OPT const ZFTokenForKeyValueContainer &token = ZFTokenForKeyValueContainerDefault()
            ) const {
        zfstring ret;
        this->objectInfoOfContentT(ret, maxCount, token);
        return ret;
    }
 
public:
    zffinal void swap(ZF_IN_OUT ZFCoreOrderMap &ref);
 
public:
    zffinal void copyFrom(ZF_IN const ZFCoreOrderMap &ref);

    zffinal zfindex objectRetainCount(void) const;
 
public:
    zffinal zfindex count(void) const;

    zffinal zfbool isEmpty(void) const;

    zffinal zfbool isContain(ZF_IN const zfstring &key) const;

    zffinal void addFrom(ZF_IN const ZFCoreOrderMap &ref);

    zffinal void set(
            ZF_IN const zfstring &key
            , ZF_IN const ZFCorePointer &value
            );
    zffinal const ZFCorePointer *get(ZF_IN const zfstring &key) const;
    template<typename T_Element>
    T_Element get(ZF_IN const zfstring &key) const {
        const ZFCorePointer *t = this->get(key);
        if(t != zfnull) {
            return t->pointerValueT<T_Element>();
        }
        return zfnull;
    }

    zffinal void allKeyT(ZF_IN_OUT ZFCoreArray<zfstring> &ret) const;
    inline ZFCoreArray<zfstring> allKey(void) const {
        ZFCoreArray<zfstring> ret;
        this->allKeyT(ret);
        return ret;
    }

    zffinal void allValueT(ZF_IN_OUT ZFCoreArray<const ZFCorePointer *> &ret) const;
    inline ZFCoreArray<const ZFCorePointer *> allValue(void) const {
        ZFCoreArray<const ZFCorePointer *> ret;
        this->allValueT(ret);
        return ret;
    }

    template<typename T_Element>
    void allValueT(ZF_IN_OUT ZFCoreArray<T_Element> &ret) const {
        ret.capacity(ret.count() + this->count());
        for(zfiter it = this->iter(); it; ++it) {
            ret.add(this->iterValue<T_Element>(it));
        }
    }

    zffinal void remove(ZF_IN const zfstring &key);

    zffinal void removeAll(void);
 
    // ============================================================
    // iterator access
public:
    zffinal zfiter iter(void) const;

    zffinal zfiter iterFind(ZF_IN const zfstring &key) const;

    zffinal zfstring iterKey(ZF_IN const zfiter &it) const;
    zffinal const ZFCorePointer *iterValue(ZF_IN const zfiter &it) const;

    zffinal void iterValue(
            ZF_IN_OUT zfiter &it
            , ZF_IN const ZFCorePointer &newValue
            );
    zffinal void iterRemove(ZF_IN_OUT zfiter &it);

    zffinal void iterAdd(
            ZF_IN const zfstring &key
            , ZF_IN const ZFCorePointer &value
            );

    template<typename T_Element>
    T_Element iterValue(ZF_IN const zfiter &it) const {
        const ZFCorePointer *t = this->iterValue(it);
        if(t != zfnull) {
            return t->pointerValueT<T_Element>();
        }
        return zfnull;
    }
 
    // ============================================================
    // order map spec
public:
    zffinal const ZFCorePointer *update(ZF_IN const zfstring &key) const;
    template<typename T_Element>
    T_Element update(ZF_IN const zfstring &key) const {
        const ZFCorePointer *t = this->update(key);
        if(t != zfnull) {
            return t->pointerValueT<T_Element>();
        }
        return zfnull;
    }
 
private:
    _ZFP_ZFCoreOrderMapPrivate *d;
};
ZFOUTPUT_TYPE(ZFCoreOrderMap, {v.objectInfoT(s);})
 
ZF_NAMESPACE_GLOBAL_END
 
#endif // #ifndef _ZFI_ZFCoreOrderMap_h_