ZFCompress.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFCompress_h_
#define _ZFI_ZFCompress_h_
 
#include "ZFAlgorithmDef.h"
ZF_NAMESPACE_GLOBAL_BEGIN

ZFENUM_BEGIN(ZFLIB_ZFAlgorithm, ZFCompressLevel)
    ZFENUM_VALUE(NoCompress)
    ZFENUM_VALUE(BestSpeed)
    ZFENUM_VALUE(GoodSpeed)
    ZFENUM_VALUE(Normal)
    ZFENUM_VALUE(GoodCompress)
    ZFENUM_VALUE(BestCompress)
ZFENUM_SEPARATOR()
    ZFENUM_VALUE_REGISTER(NoCompress)
    ZFENUM_VALUE_REGISTER(BestSpeed)
    ZFENUM_VALUE_REGISTER(GoodSpeed)
    ZFENUM_VALUE_REGISTER(Normal)
    ZFENUM_VALUE_REGISTER(GoodCompress)
    ZFENUM_VALUE_REGISTER(BestCompress)
ZFENUM_END_WITH_DEFAULT(ZFLIB_ZFAlgorithm, ZFCompressLevel, Normal)
ZFENUM_REG(ZFLIB_ZFAlgorithm, ZFCompressLevel)

zfabstract ZFLIB_ZFAlgorithm ZFCompressToken : zfextend ZFIOToken {
    ZFOBJECT_DECLARE_ABSTRACT(ZFCompressToken, ZFIOToken)
 
#if 0
public:
    virtual zfstring pathType(void) zfpurevirtual;
    virtual zfstring pathData(void) zfpurevirtual;
    virtual ZFIOOpenOptionFlags ioFlags(void) zfpurevirtual;
public:
    virtual zfbool ioClose(void) zfpurevirtual;
#endif
 
public:
    virtual zfbool ioRead(
            ZF_IN_OUT const ZFOutput &output
            , ZF_IN const zfstring &itemPath
            ) zfpurevirtual;
    virtual zfbool ioWrite(
            ZF_IN const zfstring &itemPath
            , ZF_IN const ZFInput &input
            ) zfpurevirtual;

    virtual ZFInput input(ZF_IN const zfstring &itemPath);
    virtual ZFOutput output(ZF_IN const zfstring &itemPath);

    virtual zfbool ioPathCreate(ZF_IN const zfstring &itemPath) zfpurevirtual;
    virtual zfbool ioRemove(ZF_IN const zfstring &itemPath) zfpurevirtual;
    virtual zfbool ioMove(
            ZF_IN const zfstring &itemPathFrom
            , ZF_IN const zfstring &itemPathTo
            ) zfpurevirtual;

    virtual zfbool ioFindFirst(
            ZF_IN_OUT ZFIOFindData &fd
            , ZF_IN const zfstring &itemPath
            ) zfpurevirtual;
    virtual zfbool ioFindNext(ZF_IN_OUT ZFIOFindData &fd) zfpurevirtual;
    virtual void ioFindClose(ZF_IN_OUT ZFIOFindData &fd) zfpurevirtual;

    virtual zfbool ioIsExist(ZF_IN const zfstring &itemPath) {
        return this->itemIndex(itemPath) != zfindexMax();
    }

    virtual zfbool ioIsDir(ZF_IN const zfstring &itemPath) zfpurevirtual;
    virtual zfbool ioIsDirAt(ZF_IN zfindex itemIndex) zfpurevirtual;

    virtual zfindex itemCount(void) zfpurevirtual;
    virtual zfindex itemIndex(ZF_IN const zfstring &itemPath) zfpurevirtual;
    virtual zfstring itemPath(ZF_IN zfindex itemIndex) {
        zfstring ret;
        if(this->itemPathT(ret, itemIndex)) {
            return ret;
        }
        else {
            return zfnull;
        }
    }

    virtual zfbool itemPathT(
            ZF_IN_OUT zfstring &itemPath
            , ZF_IN zfindex itemIndex
            ) zfpurevirtual;
 
private:
    zfoverride
    virtual zfindex ioRead(
            ZF_OUT void *buf
            , ZF_IN zfindex maxByteSize
            ) {
        ZFCoreCriticalNotSupported();
        return 0;
    }
    zfoverride
    virtual zfindex ioWrite(
            ZF_IN const void *src
            , ZF_IN_OPT zfindex maxByteSize = zfindexMax()
            ) {
        ZFCoreCriticalNotSupported();
        return 0;
    }
    zfoverride
    virtual zfbool ioSeek(
            ZF_IN zfindex byteSize
            , ZF_IN_OPT ZFSeekPos seekPos = ZFSeekPosBegin
            ) {
        ZFCoreCriticalNotSupported();
        return zffalse;
    }
    zfoverride
    virtual zfindex ioTell(void) {
        ZFCoreCriticalNotSupported();
        return zfindexMax();
    }
    zfoverride
    virtual zfindex ioSize(void) {
        ZFCoreCriticalNotSupported();
        return zfindexMax();
    }
};
 
// ============================================================
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFAlgorithm, zfautoT<ZFCompressToken>, ZFCompressOpen
        , ZFMP_IN(const ZFPathInfo &, pathInfo)
        , ZFMP_IN(ZFIOOpenOptionFlags, flags)
        , ZFMP_IN_OPT(ZFCompressLevel, compressLevel, v_ZFCompressLevel::EnumDefault())
        )
 
// ============================================================
// util
ZFMETHOD_FUNC_DECLARE_4(ZFLIB_ZFAlgorithm, zfbool, ZFCompressFile
        , ZFMP_IN_OUT(const ZFPathInfo &, outputCompress)
        , ZFMP_IN_OUT(const ZFInput &, inputRaw)
        , ZFMP_IN_OPT(const zfstring &, itemPath, zftext("content"))
        , ZFMP_IN_OPT(ZFCompressLevel, compressLevel, v_ZFCompressLevel::EnumDefault())
        )
ZFMETHOD_FUNC_DECLARE_3(ZFLIB_ZFAlgorithm, zfbool, ZFDecompressFile
        , ZFMP_IN_OUT(const ZFOutput &, outputRaw)
        , ZFMP_IN_OUT(const ZFPathInfo &, inputCompress)
        , ZFMP_IN_OPT(const zfstring &, itemPath, zftext("content"))
        )

ZFMETHOD_FUNC_DECLARE_5(ZFLIB_ZFAlgorithm, zfbool, ZFCompressDir
        , ZFMP_IN_OUT(const ZFPathInfo &, outputCompress)
        , ZFMP_IN(const ZFPathInfo &, inputPathInfo)
        , ZFMP_IN_OPT(const zfstring &, itemPath, zfnull)
        , ZFMP_IN_OPT(ZFIOOpenOptionFlags, flags, v_ZFIOOpenOption::e_Modify)
        , ZFMP_IN_OPT(ZFCompressLevel, compressLevel, v_ZFCompressLevel::EnumDefault())
        )
ZFMETHOD_FUNC_DECLARE_2(ZFLIB_ZFAlgorithm, zfbool, ZFDecompressDir
        , ZFMP_IN(const ZFPathInfo &, outputPathInfo)
        , ZFMP_IN_OUT(const ZFPathInfo &, inputCompress)
        )
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFCompress_h_