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 zfindexMax();
        }
    }

    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 zfindexMax();
        }
    }

    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 {
        zfindex blockSize = zfmMin(count, (zfindex)128);
        do {
            buf.capacity(buf.length() + blockSize + 1);
            zfindex read = this->execute(buf.zfunsafe_buffer() + buf.length(), blockSize);
            if(read == 0 || read == zfindexMax()) {
                break;
            }
            buf.zfunsafe_length(buf.length() + read);
            buf.zfunsafe_buffer()[buf.length()] = '\0';
            if(count != zfindexMax()) {
                count -= blockSize;
                if(count == 0) {
                    break;
                }
            }
        } while(zftrue);
        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_