ZFArray.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFArray_h_
#define _ZFI_ZFArray_h_
 
#include "ZFContainer.h"
 
ZF_NAMESPACE_GLOBAL_BEGIN
 
zfclassFwd _ZFP_ZFArrayPrivate;
zfclass ZFLIB_ZFCore ZFArray : zfextend ZFContainer {
    ZFOBJECT_DECLARE(ZFArray, ZFContainer)
 
public:
    ZFMETHOD_DECLARE_0(zfindex, count)
 
    
    ZFMETHOD_DECLARE_0(zfbool, isEmpty)

    virtual zfbool isContain(
            ZF_IN ZFObject *obj
            , ZF_IN_OPT ZFComparer<ZFObject *>::Comparer comparer = ZFComparerDefault
            );
    ZFMETHOD_DECLARE_2(zfbool, isContain
            , ZFMP_IN(ZFObject *, obj)
            , ZFMP_IN(const ZFListener &, comparer)
            )

    ZFMETHOD_DECLARE_1(zfany, get
            , ZFMP_IN(zfindex, index)
            )

    ZFMETHOD_DECLARE_0(zfany, getFirst)

    ZFMETHOD_DECLARE_0(zfany, getLast)

    virtual zfindex find(
            ZF_IN ZFObject *obj
            , ZF_IN_OPT ZFComparer<ZFObject *>::Comparer comparer = ZFComparerDefault
            );
    ZFMETHOD_DECLARE_2(zfindex, find
            , ZFMP_IN(ZFObject *, obj)
            , ZFMP_IN(const ZFListener &, comparer)
            )

    virtual zfindex findReversely(
            ZF_IN ZFObject *obj
            , ZF_IN_OPT ZFComparer<ZFObject *>::Comparer comparer = ZFComparerDefault
            );
    ZFMETHOD_DECLARE_2(zfindex, findReversely
            , ZFMP_IN(ZFObject *, obj)
            , ZFMP_IN(const ZFListener &, comparer)
            )
 
public:
    ZFMETHOD_DECLARE_2(void, add
            , ZFMP_IN(ZFObject *, obj)
            , ZFMP_IN(zfindex, indexAddTo)
            )
    ZFMETHOD_DECLARE_1(void, add
            , ZFMP_IN(ZFObject *, obj)
            )
    ZFMETHOD_DECLARE_1(void, addFrom
            , ZFMP_IN(ZFContainer *, another)
            )

    ZFMETHOD_DECLARE_2(void, set
            , ZFMP_IN(zfindex, index)
            , ZFMP_IN(ZFObject *, obj)
            )

    virtual zfbool removeElement(
            ZF_IN ZFObject *obj
            , ZF_IN_OPT ZFComparer<ZFObject *>::Comparer comparer = ZFComparerDefault
            );
    ZFMETHOD_DECLARE_2(zfbool, removeElement
            , ZFMP_IN(ZFObject *, obj)
            , ZFMP_IN(const ZFListener &, comparer)
            )
    virtual zfbool removeElementReversely(
            ZF_IN ZFObject *obj
            , ZF_IN_OPT ZFComparer<ZFObject *>::Comparer comparer = ZFComparerDefault
            );
    ZFMETHOD_DECLARE_2(zfbool, removeElementReversely
            , ZFMP_IN(ZFObject *, obj)
            , ZFMP_IN(const ZFListener &, comparer)
            )
    virtual zfindex removeElementAll(
            ZF_IN ZFObject *obj
            , ZF_IN_OPT ZFComparer<ZFObject *>::Comparer comparer = ZFComparerDefault
            );
    ZFMETHOD_DECLARE_2(zfindex, removeElementAll
            , ZFMP_IN(ZFObject *, obj)
            , ZFMP_IN(const ZFListener &, comparer)
            )

    ZFMETHOD_DECLARE_2(void, remove
            , ZFMP_IN(zfindex, index)
            , ZFMP_IN_OPT(zfindex, count, 1)
            )
    ZFMETHOD_DECLARE_1(zfauto, removeAndGet
            , ZFMP_IN(zfindex, index)
            )
    ZFMETHOD_DECLARE_0(void, removeFirst)
    ZFMETHOD_DECLARE_0(zfauto, removeFirstAndGet)
    ZFMETHOD_DECLARE_0(void, removeLast)
    ZFMETHOD_DECLARE_0(zfauto, removeLastAndGet)
    ZFMETHOD_DECLARE_0(void, removeAll)

    ZFMETHOD_DECLARE_2(void, move
            , ZFMP_IN(zfindex, fromIndex)
            , ZFMP_IN(zfindex, toIndexOrIndexMax)
            )

    virtual void sort(
            ZF_IN_OPT zfindex start = 0
            , ZF_IN_OPT zfindex count = zfindexMax()
            , ZF_IN_OPT ZFComparer<ZFObject *>::Comparer comparer = ZFComparerDefault
            );
    ZFMETHOD_DECLARE_3(void, sort
            , ZFMP_IN(zfindex, start)
            , ZFMP_IN(zfindex, count)
            , ZFMP_IN(const ZFListener &, comparer)
            )
    virtual void sortReversely(
            ZF_IN_OPT zfindex start = 0
            , ZF_IN_OPT zfindex count = zfindexMax()
            , ZF_IN_OPT ZFComparer<ZFObject *>::Comparer comparer = ZFComparerDefault
            );
    ZFMETHOD_DECLARE_3(void, sortReversely
            , ZFMP_IN(zfindex, start)
            , ZFMP_IN(zfindex, count)
            , ZFMP_IN(const ZFListener &, comparer)
            )
 
    // ============================================================
    // extra iterable
public:
    ZFMETHOD_DECLARE_1(zfiter, iterForIndex
            , ZFMP_IN(zfindex, index)
            )
 
    // ============================================================
    // ZFIterable
public:
    ZFMETHOD_DECLARE_0(zfiter, iter)

    ZFMETHOD_DECLARE_1(zfiter, iterFind
            , ZFMP_IN(ZFObject *, element)
            )

    ZFMETHOD_DECLARE_1(zfany, iterValue
            , ZFMP_IN(const zfiter &, it)
            )
 
public:
    ZFMETHOD_DECLARE_2(void, iterValue
            , ZFMP_IN_OUT(zfiter &, it)
            , ZFMP_IN(ZFObject *, value)
            )
    ZFMETHOD_DECLARE_1(void, iterRemove
            , ZFMP_IN_OUT(zfiter &, it)
            )

    ZFMETHOD_DECLARE_1(void, iterAdd
            , ZFMP_IN(ZFObject *, value)
            )
    ZFMETHOD_DECLARE_2(void, iterAdd
            , ZFMP_IN(ZFObject *, value)
            , ZFMP_IN_OUT(zfiter &, it)
            )
 
protected:
    ZFOBJECT_ON_INIT_DECLARE_1(ZFMP_IN(ZFContainer *, another))
    zfoverride
    virtual void objectOnInit(void);
    zfoverride
    virtual void objectOnDealloc(void);
 
private:
    _ZFP_ZFArrayPrivate *d;
};
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFArray_h_