iobase.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_iobase_h
#define INCL_evo_iobase_h

#include "substring.h"
#include "impl/sysio.h"

// Namespace: evo
namespace evo {



struct IoBase : public SafeBool<IoBase> {
    IoBase() : error_(ENone), excep_(EVO_EXCEPTIONS) {
    }

    virtual ~IoBase() {
    }

    bool operator!() const {
        return (error_ != ENone);
    }

    bool excep() const {
        return excep_;
    }

    void excep(bool val) {
        excep_ = val;
    }

    Error error() const {
        return error_;
    }

    virtual bool isopen() const {
        return false;
    }

    virtual ulong readbin(void* buf, ulong size) {
        EVO_PARAM_UNUSED(buf);
        EVO_PARAM_UNUSED(size);
        error_ = ENone;
        return 0;
    }

    virtual ulong writebin(const void* buf, ulong size) {
        EVO_PARAM_UNUSED(buf);
        EVO_PARAM_UNUSED(size);
        error_ = ENotImpl;
        EVO_THROW_ERR_CHECK(evo::ExceptionStreamOut, "Stream doesn't support writebin()", error_, excep_);
        return 0;
    }

    virtual bool flush() {
        error_ = ENone;
        return true;
    }

protected:
    Error error_;        
    bool  excep_;        
};


struct StreamBase : public IoBase {
    typedef ulong Size;     

    StreamBase() {
    }

    virtual ~StreamBase() {
    }

    virtual ulong readtext(char* buf, ulong size) {
        EVO_PARAM_UNUSED(buf);
        EVO_PARAM_UNUSED(size);
        error_ = ENone;
        return 0;
    }

    virtual bool readline(String& str, ulong maxlen=0) {
        EVO_PARAM_UNUSED(str);
        EVO_PARAM_UNUSED(maxlen);
        error_ = ENone;
        return false;
    }

    virtual ulong writechar(char ch, ulong count=1) {
        EVO_PARAM_UNUSED(ch);
        EVO_PARAM_UNUSED(count);
        error_ = ENotImpl;
        EVO_THROW_ERR_CHECK(evo::ExceptionStreamOut, "Stream doesn't support writechar()", error_, excep_);
        return 0;
    }

    virtual ulong writetext(const char* buf, ulong size) {
        EVO_PARAM_UNUSED(buf);
        EVO_PARAM_UNUSED(size);
        error_ = ENotImpl;
        EVO_THROW_ERR_CHECK(evo::ExceptionStreamOut, "Stream doesn't support writetext()", error_, excep_);
        return 0;
    }

    virtual Size writequoted(const char* buf, Size size, char delim, bool optional=false) {
        EVO_PARAM_UNUSED(buf);
        EVO_PARAM_UNUSED(size);
        EVO_PARAM_UNUSED(delim);
        EVO_PARAM_UNUSED(optional);
        error_ = ENotImpl;
        EVO_THROW_ERR_CHECK(evo::ExceptionStreamOut, "Stream doesn't support writequoted()", error_, excep_);
        return 0;
    }

    virtual ulong writeline(const char* buf, ulong size) {
        EVO_PARAM_UNUSED(buf);
        EVO_PARAM_UNUSED(size);
        error_ = ENotImpl;
        EVO_THROW_ERR_CHECK(evo::ExceptionStreamOut, "Stream doesn't support writeline()", error_, excep_);
        return 0;
    }

    virtual char* write_direct(Size size) {
        EVO_PARAM_UNUSED(size);
        error_ = ENotImpl;
        EVO_THROW_ERR_CHECK(evo::ExceptionStreamOut, "Stream doesn't support write_direct()", error_, excep_);
        return NULL;
    }

    char* write_direct_multi(Size& available, Size reserve_size) {
        EVO_PARAM_UNUSED(available);
        EVO_PARAM_UNUSED(reserve_size);
        error_ = ENotImpl;
        EVO_THROW_ERR_CHECK(evo::ExceptionStreamOut, "Stream doesn't support write_direct_multi()", error_, excep_);
        return NULL;
    }

    char* write_direct_flush(Size& available, Size written_size, Size reserve_size) {
        EVO_PARAM_UNUSED(available);
        EVO_PARAM_UNUSED(written_size);
        EVO_PARAM_UNUSED(reserve_size);
        error_ = ENotImpl;
        EVO_THROW_ERR_CHECK(evo::ExceptionStreamOut, "Stream doesn't support write_direct_flush()", error_, excep_);
        return NULL;
    }

    virtual bool write_direct_finish(Size size) {
        EVO_PARAM_UNUSED(size);
        error_ = ENotImpl;
        EVO_THROW_ERR_CHECK(evo::ExceptionStreamOut, "Stream doesn't support write_direct_finish()", error_, excep_);
        return false;
    }
};


template<class T>
struct StreamFormatter {
    typedef typename T::Size   Size;    
    typedef T                  Out;     
    typedef StreamFormatter<T> This;    

    Out&       out;                     
    FmtAttribs fmt;                     

    StreamFormatter(Out& out) : out(out) {
    }

    StreamFormatter(const This& src) : out(src.out), fmt(src.fmt) {
    }

    This& operator=(const This& src) {
        memcpy(&fmt, &src.fmt, sizeof(FmtAttribs));
        return *this;
    }

    Out& write_out()
        { return *this; }

    // Field
        
    This& operator<<(FmtAlign align)
        { fmt.field.align = align; return *this; }

    This& operator<<(FmtWidth width)
        { fmt.field.width = width; return *this; }

    This& operator<<(const FmtSetField& field)
        { fmt.field.merge(field); return *this; }

    // Newlines

    This& operator<<(Newline nl)
        { out << nl; return *this; }

    This& operator<<(NewlineDefault nl)
        { out << nl; return *this; }

    This& operator<<(const NewlineValue& nl)
        { out << nl; return *this; }

    This& operator<<(Flush) {
        if (out.error() == ENone)
            out.flush();
        return *this;
    }

    // Null

    This& operator<<(const FmtSetNull& null)
        { fmt.null = null; return *this; }

    // Bools

    This& operator<<(bool val) {
        if (val)
            out.writetext("true", 4);
        else
            out.writetext("false", 5);
        return *this;
    }

    // Chars

    This& operator<<(char ch) {
        if (out.error() == ENone)
            out.writechar(ch, 1);
        return *this;
    }

    This& operator<<(const FmtChar& ch) {
        if (out.error() == ENone)
            out.writefmtchar(ch.ch, ch.count, fmt.field);
        return *this;
    }

    // Strings

    This& operator<<(const FmtString& str) {
        if (out.error() == ENone) {
            FmtSetField fmtfield(fmt.field);
            fmtfield.merge(str.fmt);
            out.writefmtstr(str.str.data_, str.str.size_, fmtfield);
        }
        return *this;
    }

    This& operator<<(const char* val) {
        if (out.error() == ENone) {
            if (val == NULL) {
                if (fmt.null.size > 0)
                    out.writefmtstr(fmt.null.str, fmt.null.size, fmt.field);
            } else if (*val != '\0')
                out.writefmtstr(val, (ulong)strlen(val), fmt.field);
        }
        return *this;
    }

    template<class TSize>
    This& operator<<(const ListBase<char,TSize>& str) {
        if (out.error() == ENone) {
            if (str.data_ == NULL) {
                if (fmt.null.size > 0)
                    out.writefmtstr(fmt.null.str, fmt.null.size, fmt.field);
            } else if (str.size_ != '\0')
                out.writefmtstr(str.data_, str.size_, fmt.field);
        }
        return *this;
    }

    // Integers

    This& operator<<(FmtBase base)
        { fmt.num_int.base = base; return *this; }

    This& operator<<(FmtBasePrefix prefix)
        { fmt.num_int.prefix = prefix; return *this; }

    This& operator<<(const FmtSetInt& fmt_int)
        { fmt.num_int.merge(fmt_int); return *this; }

    This& operator<<(short num)
        { out.writefmtnum(num, fmt.num_int, &fmt.field); return *this; }

    This& operator<<(int num)
        { out.writefmtnum(num, fmt.num_int, &fmt.field); return *this; }

    This& operator<<(long num)
        { out.writefmtnum(num, fmt.num_int, &fmt.field); return *this; }

    This& operator<<(longl num)
        { out.writefmtnum(num, fmt.num_int, &fmt.field); return *this; }

    This& operator<<(ushort num)
        { out.writefmtnumu(num, fmt.num_int, &fmt.field); return *this; }

    This& operator<<(uint num)
        { out.writefmtnumu(num, fmt.num_int, &fmt.field); return *this; }

    This& operator<<(ulong num)
        { out.writefmtnumu(num, fmt.num_int, &fmt.field); return *this; }

    This& operator<<(ulongl num)
        { out.writefmtnumu(num, fmt.num_int, &fmt.field); return *this; }

    template<class U>
    This& operator<<(const IntegerT<U>& num) {
        if (num.null()) {
            if (fmt.null.size > 0)
                out.writefmtstr(fmt.null.str, fmt.null.size, fmt.field);
        } else if (IntegerT<U>::SIGN)
            out.writefmtnum(num.value(), fmt.num_int, &fmt.field);
        else
            out.writefmtnumu(num.value(), fmt.num_int, &fmt.field);
        return *this;
    }

    // Floats

    This& operator<<(FmtPrecision prec)
        { fmt.num_flt.precision = prec; return *this; }

    This& operator<<(const FmtSetFloat& fmt_flt)
        { fmt.num_flt.merge(fmt_flt); return *this; }

    This& operator<<(float num)
        { out.writefmtnumf(num, fmt.num_flt, &fmt.field); return *this; }

    This& operator<<(double num)
        { out.writefmtnumf(num, fmt.num_flt, &fmt.field); return *this; }

    This& operator<<(ldouble num)
        { out.writefmtnumf(num, fmt.num_flt, &fmt.field); return *this; }

    template<class U>
    This& operator<<(const FloatT<U>& num) {
        if (num.null()) {
            if (fmt.null.size > 0)
                out.writefmtstr(fmt.null.str, fmt.null.size, fmt.field);
        } else
            out.writefmtnumf(num.value(), fmt.num_flt, &fmt.field);
        return *this;
    }

    // Pointer

    This& operator<<(const FmtPtr& fmtptr)
        { out.writefmtnumu((ulong)fmtptr.ptr, fmtptr.fmt, &fmt.field); return *this; }

    // Dump

    This& operator<<(const FmtDump& fmtdump)
        { out.writefmtdump(fmtdump); return *this; }
};


template<class T>
class Stream : public StreamBase {
public:
    typedef typename T::Handle Handle;                  
    typedef Stream<T>          This;                    
    typedef This               Out;                     

    typedef StreamFormatter<This> Format;               

    typedef typename T::ExceptionInT  ExceptionInT;     
    typedef typename T::ExceptionOutT ExceptionOutT;    

    Stream(Newline newlines=NL_SYS) :
        owned_(false),
        bufrd_(0, newlines),
        bufwr_(0, newlines),
        savepos_(0),
        rwlast_(rwlNONE)
        { }

    ~Stream() {
        close();
    }

    Handle handle() const {
        return device_.handle;
    }

    RawBuffer& bufread() {
        return bufrd_.readbuf;
    }

    IoWriter& bufwrite() {
        return bufwr_;
    }

    void attach(Open mode, Handle handle, bool owned=true, bool flushlines=false) {
        close();
        device_.handle = handle;
        if (device_.isopen()) {
            init(mode, flushlines);
            owned_ = owned;
        }
    }

    Handle detach() {
        if (device_.isopen()) {
            if (bufwr_.used > 0)
                bufwr_.flush(device_);
            bufrd_.close();
            bufwr_.close();
            owned_ = false;
        }
        return device_.detach();
    }

    bool close() {
        if (device_.isopen()) {
            if (bufwr_.used > 0) {
                error_ = bufwr_.flush(device_);
            } else
                error_ = ENone;
            bufrd_.close();
            bufwr_.close();
            if (owned_) {
                device_.close();
                owned_ = false;
            } else
                device_.detach();
            return (error_ == ENone);
        }
        return true;
    }

    bool isopen() const {
        return device_.isopen();
    }

    ulong readbin(void* buf, ulong size) {
        if (T::STREAM_SEEKABLE && rwlast_ != rwlREAD && !readprep())
            return 0;
        size = bufrd_.readbin(error_, device_, buf, size);
        EVO_THROW_ERR_CHECK(ExceptionInT, "Stream binary read failed", error_, (excep_ && size == 0 && error_ != ENone && error_ != EEnd));
        return size;
    }

    ulong readtext(char* buf, ulong size) {
        if (T::STREAM_SEEKABLE && rwlast_ != rwlREAD && !readprep())
            return 0;
        size = bufrd_.readtext(error_, device_, buf, size);
        EVO_THROW_ERR_CHECK(ExceptionInT, "Stream text read failed", error_, (excep_ && size == 0 && error_ != ENone && error_ != EEnd));
        return size;
    }

    bool readline(String& str, ulong maxlen=0) {
        if (T::STREAM_SEEKABLE && rwlast_ != rwlREAD && !readprep())
            return false;
        error_ = bufrd_.readline(str, device_, maxlen);
        if (error_ != ENone && error_ != EEnd) {
            EVO_THROW_ERR_CHECK(ExceptionInT, "Stream text line read failed", error_, excep_);
            return false;
        }
        return true;
    }

    bool flush() {
        error_ = bufwr_.flush(device_);
        if (error_ != ENone) {
            EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream flush failed", error_, excep_);
            return false;
        }
        return true;
    }

    ulong writebin(const void* buf, ulong size) {
        if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
            return 0;
        size = bufwr_.writebin(error_, device_, buf, size);
        EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream binary write failed", error_, (excep_ && size == 0 && error_ != ENone));
        return size;
    }

    ulong writechar(char ch, ulong count=1) {
        if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
            return 0;
        count = bufwr_.writetext_char(error_, device_, ch, count);
        EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write failed", error_, (excep_ && count == 0 && error_ != ENone));
        return count;
    }

    ulong writetext(const char* buf, ulong size) {
        if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
            return 0;
        size = bufwr_.writetext(error_, device_, buf, size);
        EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write failed", error_, (excep_ && size == 0 && error_ != ENone));
        return size;
    }

    Size writequoted(const char* buf, Size size, char delim, bool optional=false) {
        bool quote_optional = false;
        const StrQuoting::Type type = StrQuoting::get(quote_optional, buf, size, delim);
        switch (type) {
            case StrQuoting::tSINGLE:
                if (quote_optional && optional)
                    return writebin(buf, size);
            case StrQuoting::tDOUBLE:
            case StrQuoting::tBACKTICK: {
                const char ch = "'\"`"[(uint)type];
                const Size result = size + 2;
                if (writebin(&ch, 1) == 1 && writebin(buf, size) == size && writebin(&ch, 1) == 1)
                    return result;
                break;
            }
            case StrQuoting::tSINGLE3:
            case StrQuoting::tDOUBLE3:
            case StrQuoting::tBACKTICK3: {
                const char* str = &"'''\"\"\"```"[(uint(type) - 3) * 3];
                const Size result = size + 6;
                if (writebin(str, 3) == 3 && writebin(buf, size) == size && writebin(str, 3) == 3)
                    return result;
                break;
            }
            case StrQuoting::tBACKTICK_DEL: {
                const char* str = "`\x7F";
                const Size result = size + 4;
                if (writebin(str, 2) != 2 || writebin(buf, size) != size || writebin(str, 2) != 2)
                    return result;
                break;
            }
            case StrQuoting::tERROR:
                error_ = EInval;
                EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write failed on unquotable text", error_, excep_);
                break;
        }
        return 0;
    }

    ulong writeline(const char* buf, ulong size) {
        if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
            return 0;
        ulong writtensize = bufwr_.writetext(error_, device_, buf, size), writtensize2;
        bufwr_.partnl = 0;
        if ( writtensize == 0 || (writtensize2=bufwr_.writebin(error_, device_, bufwr_.newline, bufwr_.newlinesize)) == 0 ) {
            EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text line write failed", error_, excep_);
            return 0;
        }
        return writtensize + writtensize2;
    }

    Out& write_out()
        { return *this; }

    char* write_direct(Size size) {
        if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
            return 0;
        if (size > bufwr_.size) {
            EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream not large enough for write_direct()", error_, excep_);
            return NULL;
        }
        if (bufwr_.avail() < size) {
            error_ = bufwr_.flush(device_);
            if (error_ != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream flush failed", error_, excep_);
                return NULL;
            }
        }
        bufwr_.partnl = 0;
        return bufwr_.data + bufwr_.used;
    }

    char* write_direct_multi(Size& available, Size reserve_size) {
        if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
            return 0;
        if (reserve_size > bufwr_.avail()) {
            error_ = bufwr_.flush(device_);
            if (error_ != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream flush failed", error_, excep_);
                return NULL;
            }
            if (reserve_size > bufwr_.size)
                available = (Size)bufwr_.size;
            else
                available = reserve_size;
        } else {
            available = reserve_size;
            if (reserve_size == 0)
                return (char*)1; // finished
        }
        bufwr_.partnl = 0;
        return bufwr_.data + bufwr_.used;
    }

    char* write_direct_flush(Size& available, Size written_size, Size reserve_size) {
        bufwr_.used += written_size;
        assert( bufwr_.used <= bufwr_.size );

        error_ = bufwr_.flush(device_);
        if (error_ != ENone) {
            EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream flush failed", error_, excep_);
            return NULL;
        }

        if (reserve_size > bufwr_.size) {
            available = (Size)bufwr_.size;
        } else {
            available = reserve_size;
            if (reserve_size == 0)
                return (char*)1; // finished
        }

        return bufwr_.data;
    }

    bool write_direct_finish(Size size) {
        bufwr_.used += size;
        assert( bufwr_.used <= bufwr_.size );
        return true;
    }

    template<class TNum>
    bool writenum(TNum num, int base=fDEC) {
        if (error_ == ENone) {
            if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
                return false;
            error_ = bufwr_.writenum(device_, num, base);
            if (error_ != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write number failed", error_, excep_);
                return false;
            }
            return true;
        }
        EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write number blocked by previous error", error_, excep_);
        return false;
    }

    template<class TNum>
    bool writenumu(TNum num, int base=fDEC) {
        if (error_ == ENone) {
            if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
                return false;
            error_ = bufwr_.writenumu(device_, num, base);
            if (error_ != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write number failed", error_, excep_);
                return false;
            }
            return true;
        }
        EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write number blocked by previous error", error_, excep_);
        return false;
    }

    template<class TNum>
    bool writenumf(TNum num, int precision=fPREC_AUTO) {
        if (error_ == ENone) {
            if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
                return false;
            error_ = bufwr_.writenumf(device_, num, precision);
            if (error_ != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write number failed", error_, excep_);
                return false;
            }
            return true;
        }
        EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write number blocked by previous error", error_, excep_);
        return false;
    }

    bool writefmtchar(char ch, ulong count, const FmtSetField& field) {
        if (error_ == ENone) {
            if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
                return false;
            error_ = bufwr_.writefmtchar(device_, ch, count, field);
            EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text formatted write char failed", error_, (excep_ && error_ != ENone));
            return true;
        }
        EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write formatted char blocked by previous error", error_, excep_);
        return false;
    }

    bool writefmtstr(const char* buf, ulong size, const FmtSetField& field) {
        if (error_ == ENone) {
            if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
                return false;
            error_ = bufwr_.writefmtstr(device_, buf, size, field);
            EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text formatted write string failed", error_, (excep_ && error_ != ENone));
            return true;
        }
        EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write formatted string blocked by previous error", error_, excep_);
        return false;
    }

    template<class TNum>
    bool writefmtnum(TNum num, const FmtSetInt& fmt, const FmtSetField* field=NULL) {
        if (error_ == ENone) {
            if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
                return false;
            error_ = bufwr_.writefmtnum(device_, num, fmt, field);
            if (error_ != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write formatted number failed", error_, excep_);
                return false;
            }
            return true;
        }
        EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write formatted number blocked by previous error", error_, excep_);
        return false;
    }

    template<class TNum>
    bool writefmtnumu(TNum num, const FmtSetInt& fmt, const FmtSetField* field=NULL) {
        if (error_ == ENone) {
            if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
                return false;
            error_ = bufwr_.writefmtnumu(device_, num, fmt, field);
            if (error_ != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write formatted number failed", error_, excep_);
                return false;
            }
            return true;
        }
        EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write formatted number blocked by previous error", error_, excep_);
        return false;
    }

    template<class TNum>
    bool writefmtnumf(TNum num, const FmtSetFloat& fmt, const FmtSetField* field=NULL) {
        if (error_ == ENone) {
            if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
                return false;
            error_ = bufwr_.writefmtnumf(device_, num, fmt, field);
            if (error_ != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write formatted number failed", error_, excep_);
                return false;
            }
            return true;
        }
        EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write formatted number blocked by previous error", error_, excep_);
        return false;
    }

    bool writefmtdump(const FmtDump& fmt) {
        if (error_ == ENone) {
            if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
                return false;
            error_ = bufwr_.writefmtdump(device_, fmt, bufwr_.newline, bufwr_.newlinesize);
            if (error_ != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write hex dump failed", error_, excep_);
                return false;
            }
            return true;
        }
        EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write hex dump blocked by previous error", error_, excep_);
        return false;
    }

    bool writefmtdump(const FmtDump& fmt, Newline nl) {
        if (error_ == ENone) {
            if (T::STREAM_SEEKABLE && rwlast_ != rwlWRITE && !writeprep())
                return false;
            error_ = bufwr_.writefmtdump(device_, fmt, getnewline(nl), getnewlinesize(nl));
            if (error_ != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write hex dump failed", error_, excep_);
                return false;
            }
            return true;
        }
        EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text write hex dump blocked by previous error", error_, excep_);
        return false;
    }

    This& operator<<(This&)
        { return *this; }

    This& operator<<(Newline nl) {
        if (error_ == ENone) {
            writebin(getnewline(nl), getnewlinesize(nl));
            flush();
        }
        return *this;
    }

    This& operator<<(NewlineDefault nl) {
        EVO_PARAM_UNUSED(nl);
        if (error_ == ENone) {
            writebin(bufwr_.newline, bufwr_.newlinesize);
            flush();
        }
        return *this;
    }

    This& operator<<(const NewlineValue& nl) {
        if (error_ == ENone) {
            uint nl_size;
            const char* nl_str = nl.getnewline(nl_size, bufwr_.newline, bufwr_.newlinesize);
            writebin(nl_str, nl_size);
            flush();
        }
        return *this;
    }

    This& operator<<(Flush) {
        if (error_ == ENone)
            flush();
        return *this;
    }

    This& operator<<(bool val) {
        if (error_ == ENone) {
            if (val)
                bufwr_.writetext(error_, device_, "true", 4);
            else
                bufwr_.writetext(error_, device_, "false", 5);
        }
        return *this;
    }

    This& operator<<(char ch) {
        if (error_ == ENone)
            writechar(ch);
        return *this;
    }

    This& operator<<(const char* str) {
        if (error_ == ENone && str != NULL)
            writetext(str, (ulong)strlen(str));
        return *this;
    }

    This& operator<<(const SubString& str) {
        if (error_ == ENone && str.size_ > 0)
            writetext(str.data_, str.size_);
        return *this;
    }

    template<class TSize>
    This& operator<<(const ListBase<char,TSize>& str) {
        if (error_ == ENone && str.size_ > 0)
            writetext(str.data_, str.size_);
        return *this;
    }

    This& operator<<(int num)
        { writenum(num); return *this; }

    This& operator<<(long num)
        { writenum(num); return *this; }

    This& operator<<(longl num)
        { writenum(num); return *this; }

    This& operator<<(uint num)
        { writenumu(num); return *this; }

    This& operator<<(ulong num)
        { writenumu(num); return *this; }

    This& operator<<(ulongl num)
        { writenumu(num); return *this; }

    template<class U>
    This& operator<<(const IntegerT<U>& num) {
        if (!num.null())
            writenum(num.value());
        return *this;
    }

    This& operator<<(float num)
        { writenumf(num); return *this; }

    This& operator<<(double num)
        { writenumf(num); return *this; }

    This& operator<<(ldouble num)
        { writenumf(num); return *this; }

    template<class U>
    This& operator<<(const FloatT<U>& num) {
        if (!num.null())
            writenumf(num.value());
        return *this;
    }

    This& operator<<(const FmtChar& fmt)
        { writechar(fmt.ch, fmt.count); return *this; }

    This& operator<<(const FmtString& fmt)
        { writefmtstr(fmt.str.data_, fmt.str.size_, fmt.fmt); return *this; }

    This& operator<<(const FmtShort& fmt)
        { writefmtnum(fmt.num, fmt.fmt); return *this; }

    This& operator<<(const FmtInt& fmt)
        { writefmtnum(fmt.num, fmt.fmt); return *this; }

    This& operator<<(const FmtLong& fmt)
        { writefmtnum(fmt.num, fmt.fmt); return *this; }

    This& operator<<(const FmtLongL& fmt)
        { writefmtnum(fmt.num, fmt.fmt); return *this; }

    This& operator<<(const FmtUShort& fmt)
        { writefmtnumu(fmt.num, fmt.fmt); return *this; }

    This& operator<<(const FmtUInt& fmt)
        { writefmtnumu(fmt.num, fmt.fmt); return *this; }

    This& operator<<(const FmtULong& fmt)
        { writefmtnumu(fmt.num, fmt.fmt); return *this; }

    This& operator<<(const FmtULongL& fmt)
        { writefmtnumu(fmt.num, fmt.fmt); return *this; }

    This& operator<<(const FmtFloat& fmt)
        { writefmtnumf(fmt.num, fmt.fmt); return *this; }

    This& operator<<(const FmtFloatD& fmt)
        { writefmtnumf(fmt.num, fmt.fmt); return *this; }

    This& operator<<(const FmtFloatL& fmt)
        { writefmtnumf(fmt.num, fmt.fmt); return *this; }

    template<class U>
    This& operator<<(const FmtFieldNum<U>& fmt) {
        if (IntegerT<U>::SIGN)
            writefmtnum(fmt.num.num, fmt.num.fmt, &fmt.field);
        else
            writefmtnumu(fmt.num.num, fmt.num.fmt, &fmt.field);
        return *this;
    }

    template<class U>
    This& operator<<(const FmtFieldFloat<U>& fmt)
        { writefmtnumf(fmt.num.num, fmt.num.fmt, &fmt.field); return *this; }

    This& operator<<(const FmtPtr& fmtptr)
        { writefmtnumu((ulong)fmtptr.ptr, fmtptr.fmt); return *this; }

    This& operator<<(const FmtDump& fmt)
        { writefmtdump(fmt); return *this; }

protected:
    enum RwLast {
        rwlNONE = 0,
        rwlREAD,
        rwlWRITE
    };

    T        device_;       
    bool     owned_;        
    IoReader bufrd_;        
    IoWriter bufwr_;        
    ulongl   savepos_;      
    RwLast   rwlast_;       

    void init(Open mode, bool flushlines=false) {
        savepos_ = 0;
        rwlast_  = rwlNONE;
        if (open_readable(mode))
            bufrd_.open();
        if (open_writable(mode))
            bufwr_.open(flushlines);
    }

private:
    Stream(const This&);
    This& operator=(const This&);

    // Restore buffered read position (switching from write to read)
    bool readprep() {
        if (rwlast_ != rwlNONE) {
            if ((error_=bufwr_.flush(device_)) != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream flush failed before switch to read mode", error_, excep_);
                return false;
            }
            ulongl newpos = device_.pos(error_);
            if (error_ != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionInT, "Stream position read failed during switch to read mode", error_, excep_);
                return false;
            }
            if (newpos > savepos_ || bufrd_.readbuf.used > savepos_ || newpos < savepos_-bufrd_.readbuf.used) {
                bufrd_.readbuf.used = bufrd_.curbuf_offset = 0; // seeking outside buffered data
                device_.seek(error_, newpos, sBegin);
            } else {
                bufrd_.curbuf_offset = bufrd_.readbuf.used - (ulong)(savepos_ - newpos);
                device_.seek(error_, savepos_, sBegin);
            }
            if (error_ != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionInT, "Stream seek failed during switch to read mode", error_, excep_);
                return false;
            }
            savepos_ = 0;
        }
        rwlast_ = rwlREAD;
        return true;
    }

    // Save buffered read position (switching from read to write)
    bool writeprep() {
        if (rwlast_ != rwlNONE) {
            savepos_ = device_.pos(error_);
            if (error_ != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream position read failed during switch to write mode", error_, excep_);
                return false;
            }
            device_.seek(error_, savepos_-(bufrd_.readbuf.used-bufrd_.curbuf_offset), sBegin);
            if (error_ != ENone) {
                EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream seek failed during switch to write mode", error_, excep_);
                return false;
            }
        }
        rwlast_ = rwlWRITE;
        return true;
    }
};


}
#endif