zfiter.h

Go to the documentation of this file.

 
#ifndef _ZFI_zfiter_h_
#define _ZFI_zfiter_h_
 
#include "ZFCoreTypeDef.h"
 
ZF_NAMESPACE_GLOBAL_BEGIN

zffinal zfclassLikePOD ZFLIB_ZFCore zfiter {
 
public:
    inline zfbool valid(void) const {
        return d && d->valid();
    }

    inline void next(void) const {
        if(d) {
            d->next();
        }
    }

    inline zfiter copy(void) const {
        return zfiter(d ? d->copy() : zfnull);
    }

    inline zfbool isEqual(ZF_IN const zfiter &ref) const {
        return this->operator == (ref);
    }

    inline operator zfbool (void) const {
        return this->valid();
    }
    inline zfiter &operator ++ (void) {
        this->next();
        return *this;
    }
    inline zfiter operator ++ (int) {
        if(d) {
            zfiter ret(d->copy());
            d->next();
            return ret;
        }
        else {
            return zfnull;
        }
    }
 
    // ============================================================
public:
    zfclassNotPOD ZFLIB_ZFCore Impl {
    public:
        virtual ~Impl(void) {}
    public:
        virtual zfbool valid(void) zfpurevirtual;
        virtual void next(void) zfpurevirtual;
        virtual Impl *copy(void) zfpurevirtual;
        virtual void destroy(void) zfpurevirtual;
        virtual zfbool isEqual(ZF_IN Impl *d) zfpurevirtual;
    };
 
public:
    zfiter(void) : d(zfnull) {}
    zfiter(ZF_IN Impl *impl) : d(impl) {
    }

    inline Impl *impl(void) const {
        return d;
    }

    template<typename T_Impl>
    inline T_Impl impl(void) const {
        return (T_Impl)d;
    }
 
public:
    zffinal void objectInfoT(ZF_IN_OUT zfstring &ret) const;
    zffinal zfstring objectInfo(void) const {
        zfstring ret;
        this->objectInfoT(ret);
        return ret;
    }
 
public:
    zfiter(ZF_IN const zfnullT &dummy) : d(zfnull) {}
    zfiter(ZF_IN const zfiter &ref) : d(ref.d ? ref.d->copy() : zfnull) {}
    ~zfiter(void) {
        if(d) {
            d->destroy();
        }
    }
    zfiter &operator = (ZF_IN const zfnullT &ref) {
        if(d) {
            Impl *dOld = d;
            d = zfnull;
            if(dOld) {
                dOld->destroy();
            }
        }
        return *this;
    }
    zfiter &operator = (ZF_IN const zfiter &ref) {
        if(this != &ref) {
            Impl *dOld = d;
            d = (ref.d ? ref.d->copy() : zfnull);
            if(dOld) {
                dOld->destroy();
            }
        }
        return *this;
    }
    inline zfbool operator == (ZF_IN const zfnullT &ref) const {return !this->valid();}
    inline zfbool operator != (ZF_IN const zfnullT &ref) const {return this->valid();}
    zfbool operator == (ZF_IN const zfiter &ref) const {
        if(d == ref.d) {
            return zftrue;
        }
        else if(d == zfnull || !d->valid()) {
            return ref.d == zfnull || !ref.d->valid();
        }
        else {
            return ref.d != zfnull && d->isEqual(ref.d);
        }
    }
    inline zfbool operator != (ZF_IN const zfiter &ref) const {return !this->operator == (ref);}
private:
    Impl *d;
};
ZFOUTPUT_TYPE(zfiter, {v.objectInfoT(s);})
 
ZF_NAMESPACE_GLOBAL_END
 
#endif // #ifndef _ZFI_zfiter_h_