ZFIODef_fwd.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFIODef_fwd_h_
#define _ZFI_ZFIODef_fwd_h_
 
#include "ZFObject.h"
ZF_NAMESPACE_GLOBAL_BEGIN

#define ZFSerializableKeyword_ZFIO_pathInfo "pathInfo"
#define ZFSerializableKeyword_ZFIO_flags "flags"
#define ZFSerializableKeyword_ZFIO_localPath "localPath"
 
// ============================================================
// ZFIOOpenOption
ZFENUM_BEGIN(ZFLIB_ZFCore, ZFIOOpenOption)
    ZFENUM_VALUE_WITH_INIT(Read, 1 << 0) 
    ZFENUM_VALUE_WITH_INIT(Write, 1 << 1) 
    ZFENUM_VALUE_WITH_INIT(Modify, 1 << 2) 
ZFENUM_SEPARATOR()
    ZFENUM_VALUE_REGISTER(Read)
    ZFENUM_VALUE_REGISTER(Write)
    ZFENUM_VALUE_REGISTER(Modify)
ZFENUM_END_FLAGS(ZFLIB_ZFCore, ZFIOOpenOption, ZFIOOpenOptionFlags)
ZFENUM_REG_FLAGS(ZFLIB_ZFCore, ZFIOOpenOption, ZFIOOpenOptionFlags)
 
// ============================================================
zfclassFwd _ZFP_ZFIOFindDataPrivate;
zffinal zfclassLikePOD ZFLIB_ZFCore ZFIOFindData {
public:
    ZFIOFindData(void);
    ZFIOFindData(ZF_IN ZFIOFindData const &ref);
    ZFIOFindData &operator = (ZF_IN ZFIOFindData const &ref);
    zfbool operator == (ZF_IN ZFIOFindData const &ref) const;
    zfbool operator != (ZF_IN ZFIOFindData const &ref) const {
        return !this->operator == (ref);
    }
    ~ZFIOFindData(void);
 
public:
    const zfstring &name(void) const {
        return this->impl().name;
    }

    zfbool isDir(void) const {
        return this->impl().isDir;
    }
 
public:
    void objectInfoT(ZF_IN_OUT zfstring &ret) const;
    inline zfstring objectInfo(void) const {
        zfstring ret;
        this->objectInfoT(ret);
        return ret;
    }
 
public:
    zffinal zfclassNotPOD Impl {
    public:
        zfstring name; 
        zfbool isDir; 
        void *nativeFd; 
    public:
        Impl(void)
        : name()
        , isDir(zffalse)
        , nativeFd(zfnull)
        {
        }
    private:
        Impl(ZF_IN const Impl &);
        Impl &operator = (ZF_IN const Impl &);
    };
public:
    Impl &impl(void) const;
    void implCopy(ZF_IN const ZFIOFindData &ref) const;
    const zfstring &implName(void) const;
    void *implUserData(void) const;
    void implAttach(
            ZF_IN const zfstring &implName
            , ZF_IN_OPT void *implUserData = zfnull
            );
    void implDetach(void);
    void *implCheck(ZF_IN const zfstring &implName) const;

    void implTag(
            ZF_IN const zfstring &key
            , ZF_IN ZFObject *value
            ) const;
    zfany implTag(ZF_IN const zfstring &key) const;
private:
    _ZFP_ZFIOFindDataPrivate *d;
};
ZFTYPEID_ACCESS_ONLY_DECLARE(ZFLIB_ZFCore, ZFIOFindData, ZFIOFindData)
ZFTYPEID_ACCESS_ONLY_REG(ZFLIB_ZFCore, ZFIOFindData, ZFIOFindData)
ZFOUTPUT_TYPE(ZFIOFindData, {v.objectInfoT(s);})
 
// ============================================================
zfclassFwd ZFIOImpl;
zfabstract ZFLIB_ZFCore ZFIOToken : zfextend ZFObject {
    ZFOBJECT_DECLARE_ABSTRACT(ZFIOToken, ZFObject)
 
public:
    ZFEVENT(IOCloseOnPrepare)
    ZFEVENT(IOCloseOnFinish)
 
protected:
    zfoverride
    virtual void objectOnDeallocPrepare(void) {
        this->ioClose();
        zfsuper::objectOnDeallocPrepare();
    }
protected:
    zfoverride
    virtual inline void objectInfoImpl(ZF_IN_OUT zfstring &ret) {
        ret += this->pathType();
        ret += ZFSerializableKeyword_ZFPathInfo_separator;
        ret += this->pathData();
    }
public:
    virtual ZFPathInfo pathInfo(void) {
        return ZFPathInfo(this->pathType(), this->pathData());
    }

    virtual zfstring pathType(void) zfpurevirtual;
    virtual zfstring pathData(void) zfpurevirtual;
    virtual ZFIOOpenOptionFlags ioFlags(void) zfpurevirtual;
 
public:
    virtual zfbool ioClose(void) zfpurevirtual;
    virtual zfindex ioRead(
            ZF_OUT void *buf
            , ZF_IN zfindex maxByteSize
            ) zfpurevirtual;
    virtual zfindex ioWrite(
            ZF_IN const void *src
            , ZF_IN_OPT zfindex maxByteSize = zfindexMax()
            ) zfpurevirtual;
    virtual void ioFlush(void) {
    }

    virtual zfbool ioSeek(
            ZF_IN zfindex byteSize
            , ZF_IN_OPT ZFSeekPos seekPos = ZFSeekPosBegin
            ) zfpurevirtual;
    virtual zfindex ioTell(void) zfpurevirtual;
    virtual zfindex ioSize(void) {
        zfindex cur = this->ioTell();
        if(cur == zfindexMax()) {
            return zfindexMax();
        }
        this->ioSeek(0, ZFSeekPosEnd);
        zfindex size = this->ioTell();
        this->ioSeek(cur);
        return size;
    }
};
 
// ============================================================
zfabstract ZFLIB_ZFCore ZFIOImpl : zfextend ZFObject {
    ZFOBJECT_DECLARE_ABSTRACT(ZFIOImpl, ZFObject)
protected:
    zfoverride
    virtual inline void objectInfoImpl(ZF_IN_OUT zfstring &ret) {
        ret += ZFTOKEN_ZFObjectInfoLeft;
        ret += "ZFIOImpl:";
        ret += this->pathType();
        ret += ZFTOKEN_ZFObjectInfoRight;
    }
public:
    virtual zfstring pathType(void) zfpurevirtual;

    virtual zfbool ioIsExist(ZF_IN const zfstring &pathData) zfpurevirtual;
    virtual zfbool ioIsDir(ZF_IN const zfstring &pathData) zfpurevirtual;
    virtual zfbool ioToFileName(
            ZF_IN_OUT zfstring &ret
            , ZF_IN const zfstring &pathData
            ) zfpurevirtual;
    virtual zfbool ioToChild(
            ZF_IN_OUT zfstring &ret
            , ZF_IN const zfstring &pathData
            , ZF_IN const zfstring &childName
            ) zfpurevirtual;
    virtual zfbool ioToParent(
            ZF_IN_OUT zfstring &ret
            , ZF_IN const zfstring &pathData
            ) zfpurevirtual;
    virtual zfbool ioPathCreate(
            ZF_IN const zfstring &pathData
            , ZF_IN_OPT zfbool autoCreateParent = zftrue
            ) zfpurevirtual;
    virtual zfbool ioRemove(
            ZF_IN const zfstring &pathData
            , ZF_IN_OPT zfbool isRecursive = zftrue
            , ZF_IN_OPT zfbool isForce = zftrue
            ) zfpurevirtual;
    virtual zfbool ioMove(
            ZF_IN const zfstring &pathDataTo
            , ZF_IN const zfstring &pathDataFrom
            , ZF_IN_OPT zfbool isForce = zftrue
            ) zfpurevirtual;
    virtual zftimet ioModTime(ZF_IN const zfstring &pathData) {return zftimetInvalid();}
    virtual zfbool ioModTime(ZF_IN const zfstring &pathData, ZF_IN zftimet time) {return zffalse;}
    virtual zfbool ioFindFirst(
            ZF_IN_OUT ZFIOFindData &fd
            , ZF_IN const zfstring &pathData
            ) zfpurevirtual;
    virtual zfbool ioFindNext(ZF_IN_OUT ZFIOFindData &fd) zfpurevirtual;
    virtual void ioFindClose(ZF_IN_OUT ZFIOFindData &fd) zfpurevirtual;
    virtual zfautoT<ZFIOToken> ioOpen(
            ZF_IN const zfstring &pathData
            , ZF_IN ZFIOOpenOptionFlags flags
            , ZF_IN_OPT zfbool autoCreateParent = zftrue
            ) zfpurevirtual;
 
    // ============================================================
    // default/dummy impl
public:
    static zfbool ioIsExistDefault(ZF_IN const zfstring &pathData);
    static zfbool ioIsDirDefault(ZF_IN const zfstring &pathData);
    static zfbool ioToFileNameDefault(
            ZF_IN_OUT zfstring &ret
            , ZF_IN const zfstring &pathData
            );
    static zfbool ioToChildDefault(
            ZF_IN_OUT zfstring &ret
            , ZF_IN const zfstring &pathData
            , ZF_IN const zfstring &childName
            );
    static zfbool ioToParentDefault(
            ZF_IN_OUT zfstring &ret
            , ZF_IN const zfstring &pathData
            );
    static zfbool ioPathCreateDefault(
            ZF_IN const zfstring &pathData
            , ZF_IN_OPT zfbool autoCreateParent = zftrue
            );
    static zfbool ioRemoveDefault(
            ZF_IN const zfstring &pathData
            , ZF_IN_OPT zfbool isRecursive = zftrue
            , ZF_IN_OPT zfbool isForce = zftrue
            );
    static zfbool ioMoveDefault(
            ZF_IN const zfstring &pathDataTo
            , ZF_IN const zfstring &pathDataFrom
            , ZF_IN_OPT zfbool isForce = zftrue
            );
    static zftimet ioModTimeDefault(ZF_IN const zfstring &pathData);
    static zfbool ioModTimeDefault(ZF_IN const zfstring &pathData, ZF_IN zftimet time);
    static zfbool ioFindFirstDefault(
            ZF_IN_OUT ZFIOFindData &fd
            , ZF_IN const zfstring &pathData
            );
    static zfbool ioFindNextDefault(ZF_IN_OUT ZFIOFindData &fd);
    static void ioFindCloseDefault(ZF_IN_OUT ZFIOFindData &fd);
    static zfautoT<ZFIOToken> ioOpenDefault(
            ZF_IN const zfstring &pathData
            , ZF_IN ZFIOOpenOptionFlags flags
            , ZF_IN_OPT zfbool autoCreateParent = zftrue
            );
    static zfbool ioCloseDefault(ZF_IN void *token);
    static zfindex ioReadDefault(
            ZF_IN void *token
            , ZF_IN void *buf
            , ZF_IN zfindex maxByteSize
            );
    static zfindex ioWriteDefault(
            ZF_IN void *token
            , ZF_IN const void *src
            , ZF_IN_OPT zfindex maxByteSize = zfindexMax()
            );
    static void ioFlushDefault(ZF_IN void *token);
    static zfbool ioSeekDefault(
            ZF_IN void *token
            , ZF_IN zfindex byteSize
            , ZF_IN_OPT ZFSeekPos seekPos = ZFSeekPosBegin
            );
    static zfindex ioTellDefault(ZF_IN void *token);
    static zfindex ioSizeDefault(ZF_IN void *token);
 
    // ============================================================
    // default impl for chained path info
public:
    static zfbool ioIsExistForChained(ZF_IN const zfstring &pathData);
    static zfbool ioIsDirForChained(ZF_IN const zfstring &pathData);
    static zfbool ioToFileNameForChained(
            ZF_IN_OUT zfstring &ret
            , ZF_IN const zfstring &pathData
            );
    static zfbool ioToChildForChained(
            ZF_IN_OUT zfstring &ret
            , ZF_IN const zfstring &pathData
            , ZF_IN const zfstring &childName
            );
    static zfbool ioToParentForChained(
            ZF_IN_OUT zfstring &ret
            , ZF_IN const zfstring &pathData
            );
    static zfbool ioPathCreateForChained(
            ZF_IN const zfstring &pathData
            , ZF_IN_OPT zfbool autoCreateParent = zftrue
            );
    static zfbool ioRemoveForChained(
            ZF_IN const zfstring &pathData
            , ZF_IN_OPT zfbool isRecursive = zftrue
            , ZF_IN_OPT zfbool isForce = zftrue
            );
    static zfbool ioMoveForChained(
            ZF_IN const zfstring &pathDataTo
            , ZF_IN const zfstring &pathDataFrom
            , ZF_IN_OPT zfbool isForce = zftrue
            );
    static zftimet ioModTimeForChained(ZF_IN const zfstring &pathData);
    static zfbool ioModTimeForChained(ZF_IN const zfstring &pathData, ZF_IN zftimet time);
    static zfbool ioFindFirstForChained(
            ZF_IN_OUT ZFIOFindData &fd
            , ZF_IN const zfstring &pathData
            );
    static zfbool ioFindNextForChained(ZF_IN_OUT ZFIOFindData &fd);
    static void ioFindCloseForChained(ZF_IN_OUT ZFIOFindData &fd);
};
 
// ============================================================
ZFMETHOD_FUNC_DECLARE_1(ZFLIB_ZFCore, zfautoT<ZFIOImpl>, ZFIOImplForPathType
        , ZFMP_IN(const zfstring &, pathType)
        )
ZFMETHOD_FUNC_DECLARE_0(ZFLIB_ZFCore, ZFCoreArray<zfautoT<ZFIOImpl> >, ZFIOImplList)

ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, void, ZFIOImplRegister
        , ZFMP_IN(const zfstring &, pathType)
        , ZFMP_IN(ZFIOImpl *, ioImpl)
        )
ZFMETHOD_FUNC_DECLARE_1(ZFLIB_ZFCore, void, ZFIOImplUnregister
        , ZFMP_IN(const zfstring &, pathType)
        )

#define ZFIO_DECLARE(ZFLIB_, pathType) \
    ZFMETHOD_FUNC_DECLARE_0(ZFLIB_, const zfstring &, ZFPathType_##pathType)

#define ZFIO_DEFINE(pathType, ZFIOImpl_) \
    ZFMETHOD_FUNC_DEFINE_0(const zfstring &, ZFPathType_##pathType) { \
        static zfstring ret = zftext(ZFM_TOSTRING(pathType)); \
        return ret; \
    } \
    ZF_STATIC_REGISTER_INIT(ZFIOReg_##pathType) { \
        ZFIOImplRegister(ZFPathType_##pathType(), zfobj<ZFIOImpl_>()); \
    } \
    ZF_STATIC_REGISTER_DESTROY(ZFIOReg_##pathType) { \
        ZFIOImplUnregister(ZFPathType_##pathType()); \
    } \
    ZF_STATIC_REGISTER_END(ZFIOReg_##pathType)
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFIODef_fwd_h_