ZFFile_pathInfo.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFFile_pathInfo_h_
#define _ZFI_ZFFile_pathInfo_h_
 
#include "ZFFile_fwd.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
typedef zfbool (*ZFPathInfoCallbackIsExist)(ZF_IN const zfchar *pathData);
typedef zfbool (*ZFPathInfoCallbackIsDir)(ZF_IN const zfchar *pathData);
typedef zfbool (*ZFPathInfoCallbackToFileName)(
        ZF_IN_OUT zfstring &ret
        , ZF_IN const zfchar *pathData
        );
typedef zfbool (*ZFPathInfoCallbackToChild)(
        ZF_IN_OUT zfstring &ret
        , ZF_IN const zfchar *pathData
        , ZF_IN const zfchar *childName
        );
typedef zfbool (*ZFPathInfoCallbackToParent)(
        ZF_IN_OUT zfstring &ret
        , ZF_IN const zfchar *pathData
        );
typedef zfbool (*ZFPathInfoCallbackPathCreate)(
        ZF_IN const zfchar *pathData
        , ZF_IN_OPT zfbool autoMakeParent /* = zftrue */
        );
typedef zfbool (*ZFPathInfoCallbackRemove)(
        ZF_IN const zfchar *pathData
        , ZF_IN_OPT zfbool isRecursive /* = zftrue */
        , ZF_IN_OPT zfbool isForce /* = zftrue */
        );
typedef zfbool (*ZFPathInfoCallbackMove)(
        ZF_IN const zfchar *pathDataFrom
        , ZF_IN const zfchar *pathDataTo
        , ZF_IN_OPT zfbool isForce /* = zftrue */
        );
typedef zfbool (*ZFPathInfoCallbackFindFirst)(
        ZF_IN_OUT ZFFileFindData &fd
        , ZF_IN const zfchar *pathData
        );
typedef zfbool (*ZFPathInfoCallbackFindNext)(ZF_IN_OUT ZFFileFindData &fd);
typedef void (*ZFPathInfoCallbackFindClose)(ZF_IN_OUT ZFFileFindData &fd);
typedef void *(*ZFPathInfoCallbackOpen)(
        ZF_IN const zfchar *pathData
        , ZF_IN_OPT ZFFileOpenOptionFlags flag /* = v_ZFFileOpenOption::e_Read */
        , ZF_IN_OPT zfbool autoCreateParent /* = zftrue */
        );
typedef zfbool (*ZFPathInfoCallbackClose)(ZF_IN void *token);
typedef zfindex (*ZFPathInfoCallbackTell)(ZF_IN void *token);
typedef zfbool (*ZFPathInfoCallbackSeek)(
        ZF_IN void *token
        , ZF_IN zfindex byteSize
        , ZF_IN_OPT ZFSeekPos position /* = ZFSeekPosBegin */
        );
typedef zfindex (*ZFPathInfoCallbackRead)(
        ZF_IN void *token
        , ZF_IN void *buf
        , ZF_IN zfindex maxByteSize
        );
typedef zfindex (*ZFPathInfoCallbackWrite)(
        ZF_IN void *token
        , ZF_IN const void *src
        , ZF_IN_OPT zfindex maxByteSize /* = zfindexMax() */
        );
typedef void (*ZFPathInfoCallbackFlush)(ZF_IN void *token);
typedef zfbool (*ZFPathInfoCallbackIsEof)(ZF_IN void *token);
typedef zfbool (*ZFPathInfoCallbackIsError)(ZF_IN void *token);
typedef zfindex (*ZFPathInfoCallbackSize)(ZF_IN void *token);
 
// ============================================================
extern ZFLIB_ZFCore zfbool ZFPathInfoCallbackIsExistDefault(ZF_IN const zfchar *pathData);
extern ZFLIB_ZFCore zfbool ZFPathInfoCallbackIsDirDefault(ZF_IN const zfchar *pathData);
extern ZFLIB_ZFCore zfbool ZFPathInfoCallbackToFileNameDefault(
        ZF_IN_OUT zfstring &ret
        , ZF_IN const zfchar *pathData
        );
extern ZFLIB_ZFCore zfbool ZFPathInfoCallbackToChildDefault(
        ZF_IN_OUT zfstring &ret
        , ZF_IN const zfchar *pathData
        , ZF_IN const zfchar *childName
        );
extern ZFLIB_ZFCore zfbool ZFPathInfoCallbackToParentDefault(
        ZF_IN_OUT zfstring &ret
        , ZF_IN const zfchar *pathData
        );
extern ZFLIB_ZFCore zfbool ZFPathInfoCallbackPathCreateDefault(
        ZF_IN const zfchar *pathData
        , ZF_IN_OPT zfbool autoMakeParent = zftrue
        );
extern ZFLIB_ZFCore zfbool ZFPathInfoCallbackRemoveDefault(
        ZF_IN const zfchar *pathData
        , ZF_IN_OPT zfbool isRecursive = zftrue
        , ZF_IN_OPT zfbool isForce = zftrue
        );
extern ZFLIB_ZFCore zfbool ZFPathInfoCallbackMoveDefault(
        ZF_IN const zfchar *pathDataFrom
        , ZF_IN const zfchar *pathDataTo
        , ZF_IN_OPT zfbool isForce = zftrue
        );
extern ZFLIB_ZFCore zfbool ZFPathInfoCallbackFindFirstDefault(
        ZF_IN_OUT ZFFileFindData &fd
        , ZF_IN const zfchar *pathData
        );
extern ZFLIB_ZFCore zfbool ZFPathInfoCallbackFindNextDefault(ZF_IN_OUT ZFFileFindData &fd);
extern ZFLIB_ZFCore void ZFPathInfoCallbackFindCloseDefault(ZF_IN_OUT ZFFileFindData &fd);
extern ZFLIB_ZFCore void *ZFPathInfoCallbackOpenDefault(
        ZF_IN const zfchar *pathData
        , ZF_IN_OPT ZFFileOpenOptionFlags flag = v_ZFFileOpenOption::e_Read
        , ZF_IN_OPT zfbool autoCreateParent = zftrue
        );
extern ZFLIB_ZFCore zfbool ZFPathInfoCallbackCloseDefault(ZF_IN void *token);
extern ZFLIB_ZFCore zfindex ZFPathInfoCallbackTellDefault(ZF_IN void *token);
extern ZFLIB_ZFCore zfbool ZFPathInfoCallbackSeekDefault(
        ZF_IN void *token
        , ZF_IN zfindex byteSize
        , ZF_IN_OPT ZFSeekPos position = ZFSeekPosBegin
        );
extern ZFLIB_ZFCore zfindex ZFPathInfoCallbackReadDefault(
        ZF_IN void *token
        , ZF_IN void *buf
        , ZF_IN zfindex maxByteSize
        );
extern ZFLIB_ZFCore zfindex ZFPathInfoCallbackWriteDefault(
        ZF_IN void *token
        , ZF_IN const void *src
        , ZF_IN_OPT zfindex maxByteSize = zfindexMax()
        );
extern ZFLIB_ZFCore void ZFPathInfoCallbackFlushDefault(ZF_IN void *token);
extern ZFLIB_ZFCore zfbool ZFPathInfoCallbackIsEofDefault(ZF_IN void *token);
extern ZFLIB_ZFCore zfbool ZFPathInfoCallbackIsErrorDefault(ZF_IN void *token);
extern ZFLIB_ZFCore zfindex ZFPathInfoCallbackSizeDefault(ZF_IN void *token);
 
// ============================================================
ZFMETHOD_FUNC_DECLARE_1(ZFLIB_ZFCore, zfbool, ZFPathInfoIsExist
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        )
ZFMETHOD_FUNC_DECLARE_1(ZFLIB_ZFCore, zfbool, ZFPathInfoIsDir
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, zfbool, ZFPathInfoToFileName
        , ZFMP_IN_OUT(zfstring &, ret)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFCore, zfbool, ZFPathInfoToChild
        , ZFMP_IN_OUT(zfstring &, ret)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN(const zfchar *, childName)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, zfbool, ZFPathInfoToParent
        , ZFMP_IN_OUT(zfstring &, ret)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, zfbool, ZFPathInfoPathCreate
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(zfbool, autoMakeParent, zftrue)
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFCore, zfbool, ZFPathInfoRemove
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(zfbool, isRecursive, zftrue)
        , ZFMP_IN_OPT(zfbool, isForce, zftrue)
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFCore, zfbool, ZFPathInfoMove
        , ZFMP_IN(const ZFPathInfo &, pathInfoFrom)
        , ZFMP_IN(const zfchar *, pathDataTo)
        , ZFMP_IN_OPT(zfbool, isForce, zftrue)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, zfbool, ZFPathInfoFindFirst
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OUT(ZFFileFindData &, fd)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, zfbool, ZFPathInfoFindNext
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OUT(ZFFileFindData &, fd)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, void, ZFPathInfoFindClose
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OUT(ZFFileFindData &, fd)
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFCore, void *, ZFPathInfoOpen
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(ZFFileOpenOptionFlags, flag, v_ZFFileOpenOption::e_Read)
        , ZFMP_IN_OPT(zfbool, autoCreateParent, zftrue)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, zfbool, ZFPathInfoClose
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN(void *, token)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, zfindex, ZFPathInfoTell
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN(void *, token)
        )
ZFMETHOD_FUNC_DECLARE_4(ZFLIB_ZFCore, zfbool, ZFPathInfoSeek
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN(void *, token)
        , ZFMP_IN(zfindex, byteSize)
        , ZFMP_IN_OPT(ZFSeekPos, position, ZFSeekPosBegin)
        )
ZFMETHOD_FUNC_DECLARE_4(ZFLIB_ZFCore, zfindex, ZFPathInfoRead
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN(void *, token)
        , ZFMP_IN(void *, buf)
        , ZFMP_IN(zfindex, maxByteSize)
        )
ZFMETHOD_FUNC_DECLARE_4(ZFLIB_ZFCore, zfindex, ZFPathInfoWrite
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN(void *, token)
        , ZFMP_IN(const void *, src)
        , ZFMP_IN_OPT(zfindex, maxByteSize, zfindexMax())
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, void, ZFPathInfoFlush
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN(void *, token)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, zfbool, ZFPathInfoIsEof
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN(void *, token)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, zfbool, ZFPathInfoIsError
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN(void *, token)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, zfindex, ZFPathInfoSize
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN(void *, token)
        )

ZFMETHOD_FUNC_DECLARE_4(ZFLIB_ZFCore, zfbool, ZFPathInfoCopy
        , ZFMP_IN(const ZFPathInfo &, srcPath)
        , ZFMP_IN(const ZFPathInfo &, dstPath)
        , ZFMP_IN_OPT(zfbool, isRecursive, zftrue)
        , ZFMP_IN_OPT(zfbool, isForce, zftrue)
        )
 
// ============================================================
zfclassLikePOD ZFLIB_ZFCore ZFPathInfoImpl {
public:
    ZFPathInfoCallbackIsExist callbackIsExist; 
    ZFPathInfoCallbackIsDir callbackIsDir; 
    ZFPathInfoCallbackToFileName callbackToFileName; 
    ZFPathInfoCallbackToChild callbackToChild; 
    ZFPathInfoCallbackToParent callbackToParent; 
    ZFPathInfoCallbackPathCreate callbackPathCreate; 
    ZFPathInfoCallbackRemove callbackRemove; 
    ZFPathInfoCallbackMove callbackMove; 
    ZFPathInfoCallbackFindFirst callbackFindFirst; 
    ZFPathInfoCallbackFindNext callbackFindNext; 
    ZFPathInfoCallbackFindClose callbackFindClose; 
    ZFPathInfoCallbackOpen callbackOpen; 
    ZFPathInfoCallbackClose callbackClose; 
    ZFPathInfoCallbackTell callbackTell; 
    ZFPathInfoCallbackSeek callbackSeek; 
    ZFPathInfoCallbackRead callbackRead; 
    ZFPathInfoCallbackWrite callbackWrite; 
    ZFPathInfoCallbackFlush callbackFlush; 
    ZFPathInfoCallbackIsEof callbackIsEof; 
    ZFPathInfoCallbackIsError callbackIsError; 
    ZFPathInfoCallbackSize callbackSize; 
 
public:
    void _ZFP_init(
            ZF_IN_OPT ZFPathInfoCallbackIsExist callbackIsExist = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackIsDir callbackIsDir = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackToFileName callbackToFileName = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackToChild callbackToChild = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackToParent callbackToParent = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackPathCreate callbackPathCreate = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackRemove callbackRemove = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackMove callbackMove = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackFindFirst callbackFindFirst = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackFindNext callbackFindNext = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackFindClose callbackFindClose = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackOpen callbackOpen = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackClose callbackClose = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackTell callbackTell = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackSeek callbackSeek = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackRead callbackRead = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackWrite callbackWrite = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackFlush callbackFlush = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackIsEof callbackIsEof = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackIsError callbackIsError = zfnull
            , ZF_IN_OPT ZFPathInfoCallbackSize callbackSize = zfnull
            ) {
        this->callbackIsExist = callbackIsExist;
        this->callbackIsDir = callbackIsDir;
        this->callbackToFileName = callbackToFileName;
        this->callbackToChild = callbackToChild;
        this->callbackToParent = callbackToParent;
        this->callbackPathCreate = callbackPathCreate;
        this->callbackRemove = callbackRemove;
        this->callbackMove = callbackMove;
        this->callbackFindFirst = callbackFindFirst;
        this->callbackFindNext = callbackFindNext;
        this->callbackFindClose = callbackFindClose;
        this->callbackOpen = callbackOpen;
        this->callbackClose = callbackClose;
        this->callbackTell = callbackTell;
        this->callbackSeek = callbackSeek;
        this->callbackRead = callbackRead;
        this->callbackWrite = callbackWrite;
        this->callbackFlush = callbackFlush;
        this->callbackIsEof = callbackIsEof;
        this->callbackIsError = callbackIsError;
        this->callbackSize = callbackSize;
    }
 
public:
    inline zfbool implIsExist(ZF_IN const zfchar *pathData) const {
        return this->callbackIsExist(pathData);
    }

    inline zfbool implIsDir(ZF_IN const zfchar *pathData) const {
        return this->callbackIsDir(pathData);
    }

    inline zfbool implToFileName(
            ZF_IN_OUT zfstring &ret
            , ZF_IN const zfchar *pathData
            ) const {
        return this->callbackToFileName(ret, pathData);
    }

    inline zfbool implToChild(
            ZF_IN_OUT zfstring &ret
            , ZF_IN const zfchar *pathData
            , ZF_IN const zfchar *childName
            ) const {
        return this->callbackToChild(ret, pathData, childName);
    }

    inline zfbool implToParent(
            ZF_IN_OUT zfstring &ret
            , ZF_IN const zfchar *pathData
            ) const {
        return this->callbackToParent(ret, pathData);
    }

    inline zfbool implPathCreate(
            ZF_IN const zfchar *pathData
            , ZF_IN_OPT zfbool autoMakeParent = zftrue
            ) const {
        return this->callbackPathCreate(pathData, autoMakeParent);
    }

    inline zfbool implRemove(
            ZF_IN const zfchar *pathData
            , ZF_IN_OPT zfbool isRecursive = zftrue
            , ZF_IN_OPT zfbool isForce = zftrue
            ) const {
        return this->callbackRemove(pathData, isRecursive, isForce);
    }

    inline zfbool implMove(
            ZF_IN const zfchar *pathDataFrom
            , ZF_IN const zfchar *pathDataTo
            , ZF_IN_OPT zfbool isForce = zftrue
            ) const {
        return this->callbackMove(pathDataFrom, pathDataTo, isForce);
    }

    inline zfbool implFindFirst(
            ZF_IN_OUT ZFFileFindData &fd
            , ZF_IN const zfchar *pathData
            ) const {
        return this->callbackFindFirst(fd, pathData);
    }

    inline zfbool implFindNext(ZF_IN_OUT ZFFileFindData &fd) const {
        return this->callbackFindNext(fd);
    }

    inline void implFindClose(ZF_IN_OUT ZFFileFindData &fd) const {
        return this->callbackFindClose(fd);
    }

    inline void *implOpen(
            ZF_IN const zfchar *pathData
            , ZF_IN_OPT ZFFileOpenOptionFlags flag = v_ZFFileOpenOption::e_Read
            , ZF_IN_OPT zfbool autoCreateParent = zftrue
            ) const {
        return this->callbackOpen(pathData, flag, autoCreateParent);
    }

    inline zfbool implClose(ZF_IN void *token) const {
        return this->callbackClose(token);
    }

    inline zfindex implTell(ZF_IN void *token) const {
        return this->callbackTell(token);
    }

    inline zfbool implSeek(
            ZF_IN void *token
            , ZF_IN zfindex byteSize
            , ZF_IN_OPT ZFSeekPos position = ZFSeekPosBegin
            ) const {
        return this->callbackSeek(token, byteSize, position);
    }

    inline zfindex implRead(
            ZF_IN void *token
            , ZF_IN void *buf
            , ZF_IN zfindex maxByteSize
            ) const {
        return this->callbackRead(token, buf, maxByteSize);
    }

    inline zfindex implWrite(
            ZF_IN void *token
            , ZF_IN const void *src
            , ZF_IN_OPT zfindex maxByteSize = zfindexMax()
            ) const {
        return this->callbackWrite(token, src, maxByteSize);
    }

    inline void implFlush(ZF_IN void *token) const {
        return this->callbackFlush(token);
    }

    inline zfbool implIsEof(ZF_IN void *token) const {
        return this->callbackIsEof(token);
    }

    inline zfbool implIsError(ZF_IN void *token) const {
        return this->callbackIsError(token);
    }

    inline zfindex implSize(ZF_IN void *token) const {
        return this->callbackSize(token);
    }
};
ZFTYPEID_ACCESS_ONLY_DECLARE(ZFLIB_ZFCore, ZFPathInfoImpl, const ZFPathInfoImpl *)
ZFTYPEID_ACCESS_ONLY_REG(ZFLIB_ZFCore, ZFPathInfoImpl, const ZFPathInfoImpl *)
 
extern ZFLIB_ZFCore void _ZFP_ZFPathInfoRegister(
        ZF_IN const zfstring &pathType
        , ZF_IN const ZFPathInfoImpl &data
        );
extern ZFLIB_ZFCore void _ZFP_ZFPathInfoUnregister(ZF_IN const zfstring &pathType);

#define ZFPATHTYPE_FILEIO_REGISTER(registerSig, pathType, ...) \
    ZF_STATIC_REGISTER_INIT(ZFPathInfoReg_##registerSig) { \
        ZFPathInfoImpl data; \
        data._ZFP_init(__VA_ARGS__); \
        _ZFP_ZFPathInfoRegister(pathType, data); \
    } \
    ZF_STATIC_REGISTER_DESTROY(ZFPathInfoReg_##registerSig) { \
        _ZFP_ZFPathInfoUnregister(pathType); \
    } \
    ZF_STATIC_REGISTER_END(ZFPathInfoReg_##registerSig)

ZFMETHOD_FUNC_DECLARE_1(ZFLIB_ZFCore, const ZFPathInfoImpl *, ZFPathInfoImplForPathType
        , ZFMP_IN(const zfstring &, pathType)
        )
ZFMETHOD_FUNC_DECLARE_1(ZFLIB_ZFCore, void, ZFPathInfoImplGetAllT
        , ZFMP_IN_OUT(ZFCoreArray<zfstring> &, ret)
        )
ZFMETHOD_FUNC_INLINE_DECLARE_0(ZFLIB_ZFCore, ZFCoreArray<zfstring>, ZFPathInfoImplGetAll) {
    ZFCoreArray<zfstring> ret;
    ZFPathInfoImplGetAllT(ret);
    return ret;
}
 
// ============================================================
// utils
ZFMETHOD_FUNC_DECLARE_1(ZFLIB_ZFCore, ZFPathInfo, ZFLocalPathInfo
        , ZFMP_IN_OPT(const zfstring &, localPath, zfnull)
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFCore, zfbool, ZFPathInfoForLocalT
        , ZFMP_OUT(ZFPathInfo &, ret)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN(const zfchar *, childPath)
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFCore, zfbool, ZFPathInfoForLocalT
        , ZFMP_OUT(zfstring &, ret)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN(const zfchar *, childPath)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, ZFPathInfo, ZFPathInfoForLocal
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN(const zfchar *, childPath)
        )
 
// ============================================================
// ZFInputForPathInfo
#define ZFCallbackSerializeType_ZFInputForPathInfo "ZFInputForPathInfo"

ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, ZFInput, ZFInputForPathInfo
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(ZFFileOpenOptionFlags, flags, v_ZFFileOpenOption::e_Read)
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFCore, zfbool, ZFInputForPathInfoT
        , ZFMP_IN_OUT(ZFCallback &, ret)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(ZFFileOpenOptionFlags, flags, v_ZFFileOpenOption::e_Read)
        )

ZFMETHOD_FUNC_DECLARE_4(ZFLIB_ZFCore, ZFInput, ZFInputForPathInfoToken
        , ZFMP_IN(void *, token)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(ZFFileOpenOptionFlags, flags, v_ZFFileOpenOption::e_Read)
        , ZFMP_IN_OPT(zfbool, autoClose, zftrue)
        )
ZFMETHOD_FUNC_DECLARE_5(ZFLIB_ZFCore, zfbool, ZFInputForPathInfoTokenT
        , ZFMP_IN_OUT(ZFCallback &, ret)
        , ZFMP_IN(void *, token)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(ZFFileOpenOptionFlags, flags, v_ZFFileOpenOption::e_Read)
        , ZFMP_IN_OPT(zfbool, autoClose, zftrue)
        )
 
// ============================================================
// ZFOutputForPathInfo
#define ZFCallbackSerializeType_ZFOutputForPathInfo "ZFOutputForPathInfo"

ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, ZFOutput, ZFOutputForPathInfo
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(ZFFileOpenOptionFlags, flags, v_ZFFileOpenOption::e_Create)
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFCore, zfbool, ZFOutputForPathInfoT
        , ZFMP_IN_OUT(ZFCallback &, ret)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(ZFFileOpenOptionFlags, flags, v_ZFFileOpenOption::e_Create)
        )

ZFMETHOD_FUNC_DECLARE_4(ZFLIB_ZFCore, ZFOutput, ZFOutputForPathInfoToken
        , ZFMP_IN(void *, token)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(ZFFileOpenOptionFlags, flags, v_ZFFileOpenOption::e_Create)
        , ZFMP_IN_OPT(zfbool, autoClose, zftrue)
        )
ZFMETHOD_FUNC_DECLARE_5(ZFLIB_ZFCore, zfbool, ZFOutputForPathInfoTokenT
        , ZFMP_IN_OUT(ZFCallback &, ret)
        , ZFMP_IN(void *, token)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(ZFFileOpenOptionFlags, flags, v_ZFFileOpenOption::e_Create)
        , ZFMP_IN_OPT(zfbool, autoClose, zftrue)
        )
 
// ============================================================
// ZFInputForLocal
#define ZFCallbackSerializeType_ZFInputForLocal "ZFInputForLocal"

ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFCore, ZFInput, ZFInputForLocal
        , ZFMP_IN(const zfchar *, localPath)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(ZFFileOpenOptionFlags, flags, v_ZFFileOpenOption::e_Read)
        )
ZFMETHOD_FUNC_DECLARE_4(ZFLIB_ZFCore, zfbool, ZFInputForLocalT
        , ZFMP_OUT(ZFCallback &, ret)
        , ZFMP_IN(const zfchar *, localPath)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(ZFFileOpenOptionFlags, flags, v_ZFFileOpenOption::e_Read)
        )
 
// ============================================================
// ZFOutputForLocal
#define ZFCallbackSerializeType_ZFOutputForLocal "ZFOutputForLocal"

ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFCore, ZFOutput, ZFOutputForLocal
        , ZFMP_IN(const zfchar *, localPath)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(ZFFileOpenOptionFlags, flags, v_ZFFileOpenOption::e_Create)
        )
ZFMETHOD_FUNC_DECLARE_4(ZFLIB_ZFCore, zfbool, ZFOutputForLocalT
        , ZFMP_OUT(ZFCallback &, ret)
        , ZFMP_IN(const zfchar *, localPath)
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN_OPT(ZFFileOpenOptionFlags, flags, v_ZFFileOpenOption::e_Create)
        )
 
// ============================================================
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFCore, zfbool, ZFPathInfoChainDecode
        , ZFMP_OUT(ZFPathInfo &, chainPathInfo)
        , ZFMP_IN_OUT(zfstring &, pathData)
        , ZFMP_IN(const zfchar *, pathDataOrig)
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFCore, zfbool, ZFPathInfoChainDecodeString
        , ZFMP_OUT(zfstring &, chainPathInfoString)
        , ZFMP_IN_OUT(zfstring &, pathData)
        , ZFMP_IN(const zfchar *, pathDataOrig)
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFCore, void, ZFPathInfoChainEncodeT
        , ZFMP_IN_OUT(zfstring &, ret)
        , ZFMP_IN(const ZFPathInfo &, chainPathInfo)
        , ZFMP_IN(const zfchar *, pathData)
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFCore, zfstring, ZFPathInfoChainEncode
        , ZFMP_IN(const ZFPathInfo &, chainPathInfo)
        , ZFMP_IN(const zfchar *, pathData)
        )
 
extern ZFLIB_ZFCore const zfchar _ZFP_ZFPathInfoChainCharMap[256];
#define ZFPathInfoChainCharMap() _ZFP_ZFPathInfoChainCharMap
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFFile_pathInfo_h_