ZFIOCallback_input.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFIOCallback_input_h_
#define _ZFI_ZFIOCallback_input_h_
 
#include "ZFIOCallback_fwd.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
// ZFInput
ZFCALLBACK_DECLARE_BEGIN(ZFLIB_ZFCore, ZFInput, ZFIOCallback)
public:
    inline zfindex execute(
            ZF_OUT void *buf
            , ZF_IN zfindex count
            ) const {
        if(this->valid()) {
            return ZFCallback::executeExact<zfindex, void *, zfindex>(buf, count);
        }
        else {
            return 0;
        }
    }

    inline zfindex operator () (
            ZF_OUT void *buf
            , ZF_IN zfindex count
            ) const {
        if(this->valid()) {
            return ZFCallback::executeExact<zfindex, void *, zfindex>(buf, count);
        }
        else {
            return 0;
        }
    }

    const ZFInput &input(
            ZF_OUT void *buf
            , ZF_IN zfindex count
            , ZF_OUT_OPT zfindex *result = zfnull
            ) const {
        if(result != zfnull) {
            *result = this->execute(buf, count);
        }
        else {
            this->execute(buf, count);
        }
        return *this;
    }

    const ZFInput &input(
            ZF_OUT zfstring &buf
            , ZF_IN zfindex count
            , ZF_OUT_OPT zfindex *result = zfnull
            ) const {
        if(count == zfindexMax()) {
            count = this->execute(zfnull, zfindexMax());
            if(count == zfindexMax()) {
                if(result != zfnull) {
                    *result = zfindexMax();
                }
                return *this;
            }
        }
        void *bufTmp = zfmalloc(count);
        zfindex read = this->execute(bufTmp, count);
        if(read > count) {
            zffree(bufTmp);
            if(result != zfnull) {
                *result = zfindexMax();
            }
            return *this;
        }
        buf.append((const zfchar *)bufTmp, read);
        zffree(bufTmp);
        if(result != zfnull) {
            *result = read;
        }
        return *this;
    }
_ZFP_ZFCALLBACK_DECLARE_END_NO_ALIAS(ZFLIB_ZFCore, ZFInput, ZFIOCallback)
 
// ============================================================
// ZFInputDummy
#define ZFCallbackSerializeType_ZFInputDummy "ZFInputDummy"
extern ZFLIB_ZFCore ZFInput ZFInputDummy(void);
 
// ============================================================
// ZFInputForInputInRange
#define ZFCallbackSerializeType_ZFInputForInputInRange "ZFInputForInputInRange"

#define ZFSerializableKeyword_ZFInputForInputInRange_input "input"
#define ZFSerializableKeyword_ZFInputForInputInRange_start "start"
#define ZFSerializableKeyword_ZFInputForInputInRange_count "count"
#define ZFSerializableKeyword_ZFInputForInputInRange_autoRestorePos "autoRestorePos"
extern ZFLIB_ZFCore ZFInput ZFInputForInputInRange(
        ZF_IN const ZFInput &inputCallback
        , ZF_IN_OPT zfindex start = 0
        , ZF_IN_OPT zfindex count = zfindexMax()
        , ZF_IN_OPT zfbool autoRestorePos = zftrue
        );
 
// ============================================================
// ZFInputForBuffer
#define ZFCallbackSerializeType_ZFInputForBuffer "ZFInputForBuffer"

#define ZFSerializableKeyword_ZFInputForBuffer_buf "buf"

extern ZFLIB_ZFCore ZFInput ZFInputForBufferUnsafe(
        ZF_IN const void *src
        , ZF_IN_OPT zfindex count = zfindexMax()
        , ZF_IN_OPT zfbool serializable = zffalse
        );
extern ZFLIB_ZFCore ZFInput ZFInputForBuffer(
        ZF_IN const void *src
        , ZF_IN_OPT zfindex count = zfindexMax()
        , ZF_IN_OPT zfbool serializable = zffalse
        );

extern ZFLIB_ZFCore ZFInput ZFInputForString(
        ZF_IN const zfstring &src
        , ZF_IN_OPT zfbool serializable = zffalse
        );
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFIOCallback_input_h_