io.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_io_h
#define INCL_evo_io_h

#include "iobase.h"
#include "thread_inert.h"


#define EVO_CONSOLE static evo::Console& c = evo::con()

#if EVO_CATCH_DEBUG == 0
    #define EVO_CATCH(CODE) catch (const evo::Exception& e) { \
        evo::Console& c = evo::con(); \
        c.err << evo::NL << e.msg() << evo::SubString(" -- ", 4); \
        evo::errormsg_out(c.err, e.error()); \
        c.err << evo::NL; \
        CODE; \
    }
#else
    #define EVO_CATCH(CODE) catch (const evo::Exception& e) { \
        evo::Console& c = evo::con(); \
        c.err << evo::NL; \
        if (e.file()) \
            c.err << e.file() << '(' << e.line() << evo::SubString("): ", 3); \
        c.err << e.msg() << evo::SubString(" -- ", 4); \
        evo::errormsg_out(c.err, e.error()); \
        c.err << evo::NL; \
        CODE; \
    }
#endif


// Namespace: evo
namespace evo {



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

    typedef typename T::ExceptionInT  ExceptionInT;     

    StreamIn(Newline newlines=NL_SYS) :
        owned_(false),
        bufrd_(0, newlines)
        { }

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

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

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

    Handle detach() {
        if (device_.isopen()) {
            bufrd_.close();
            owned_ = false;
        }
        return device_.detach();
    }

    bool close() {
        if (device_.isopen()) {
            bufrd_.close();
            if (owned_) {
                device_.close();
                owned_ = false;
            } else
                device_.detach();
        }
        return true;
    }

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

    // Read methods copied from Stream, with some modifications -- it's done this way to avoid more virtual method overhead

    ulong readbin(void* buf, ulong size) {
        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) {
        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) {
        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;
    }

protected:
    T        device_;       
    bool     owned_;        
    IoReader bufrd_;        

    void init() {
        bufrd_.open();
    }

private:
    StreamIn(const This&);
    This& operator=(const This&);
};


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

    typedef StreamFormatter<This> Format;               

    typedef typename T::ExceptionOutT ExceptionOutT;    

    StreamOut(Newline newlines=NL_SYS) :
        owned_(false),
        bufwr_(0, newlines)
        { }

    ~StreamOut()
        { close(); }

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

    IoWriter& bufwrite()
        { return bufwr_; }

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

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

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

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

    // Write methods copied from Stream, with some modifications -- it's done this way to avoid more virtual method overhead

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

    ulong writebin(const void* buf, ulong size) {
        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) {
        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) {
        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) {
        ulong writtensize = bufwr_.writetext(error_, device_, buf, size);
        bufwr_.partnl = 0;
        if (writtensize == 0 || !bufwr_.writebin(error_, device_, bufwr_.newline, bufwr_.newlinesize) ) {
            EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text line write failed", error_, excep_);
            return 0;
        }
        return writtensize + bufwr_.newlinesize;
    }

    Out& write_out()
        { return *this; }

    char* write_direct(Size size) {
        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 (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) {
            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) {
            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) {
            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) {
            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) {
            error_ = bufwr_.writefmtstr(device_, buf, size, field);
            EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text formatted write failed", error_, (excep_ && error_ != ENone));
            return true;
        }
        EVO_THROW_ERR_CHECK(ExceptionOutT, "Stream text formatted write 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) {
            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) {
            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) {
            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) {
            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;
    }

    // operator<<() overloads copied from Stream

    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)
            bufwr_.writetext(error_, device_, str, (ulong)strlen(str));
        return *this;
    }

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

    template<class TSize>
    This& operator<<(const ListBase<char,TSize>& str) {
        if (error_ == ENone) {
            bufwr_.writetext(error_, device_, str.data_, str.size_);
            EVO_THROW_ERR_CHECK(evo::ExceptionStreamOut, "Stream text write (ListBase) failed", error_, (excep_ && error_ != ENone));
        }
        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()) {
            if (IntegerT<U>::SIGN)
                writenum(num.value());
            else
                writenumu(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);
        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 FmtStringWrap& fmt) {
        uint newline_size;
        const char* newline_str = fmt.newline.getnewline(newline_size, bufwr_.newline, bufwr_.newlinesize);

        SubString str(fmt.str), line, substr;
        for (uint notfirst=0; str.token_line(line); ) {
            for (;;) {
                if (line.empty()) {
                    if (writebin(newline_str, newline_size) == 0)
                        return *this;
                } else {
                    if (notfirst == 0)
                        ++notfirst;
                    else if (fmt.indent > 0 && writechar(' ', fmt.indent) == 0)
                        return *this;
                    if (fmt.width > 1 && line.size() > (Size)fmt.width) {
                        // line too long, try to find a word break
                        Size i = line.findnonwordr(0, (Size)fmt.width + 1);
                        if (i == NONE) {
                            i = (Size)fmt.width;
                        } else {
                            while (i > 0 && ascii_breaktype(line[i]) == cbtBEGIN)
                                --i;
                            if (i < (Size)fmt.width)
                                ++i;
                        }

                        substr.set(line.data(), i).stripr();
                        if (!substr.empty() && (writebin(substr.data(), substr.size()) == 0 || writebin(newline_str, newline_size) == 0))
                            return *this;

                        line.triml(i).stripl();
                        continue;
                    }
                    if (writebin(line.data(), line.size()) == 0 || writebin(newline_str, newline_size) == 0)
                        return *this;
                }
                break;
            }
        }
        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:
    T        device_;       
    bool     owned_;        
    IoWriter bufwr_;        

    void init(bool flushlines=false) {
        bufwr_.open(flushlines);
    }

private:
    StreamOut(const This&);
    This& operator=(const This&);
};


class PipeIn : public StreamIn<IoFile> {
public:
    using StreamIn<IoFile>::Handle;

    PipeIn(bool exceptions=EVO_EXCEPTIONS) {
        excep(exceptions);
    }

private:
    PipeIn(const PipeIn&);
    PipeIn& operator=(const PipeIn&);
};


class PipeOut : public StreamOut<IoFile> {
public:
    using StreamOut<IoFile>::Handle;

    PipeOut(bool exceptions=EVO_EXCEPTIONS) {
        excep(exceptions);
    }

private:
    PipeOut(const PipeOut&);
    PipeOut& operator=(const PipeOut&);
};


struct Pipe {
    PipeIn  in;
    PipeOut out;
};


struct Console {
    typedef PipeOut::Format Format;     
    typedef PipeIn  InT;                
    typedef PipeOut OutT;               

    PipeIn  in;     
    PipeOut out;    
    PipeOut err;    

    static Console& get() {
        static Console console;
        return console;
    }

private:
    static const PipeIn::Handle  HIN  = 0;
    static const PipeOut::Handle HOUT = 1;
    static const PipeOut::Handle HERR = 2;

    static const ulong IN_BUFSZ  = 4096;
    static const ulong OUT_BUFSZ = 4096;
    static const ulong ERR_BUFSZ = 1024;

    Console() {
        in.bufread().resize(  IN_BUFSZ);
        out.bufwrite().resize(OUT_BUFSZ);
        err.bufwrite().resize(ERR_BUFSZ);

        in.attach( HIN,  false);
        out.attach(HOUT, false, false);
        err.attach(HERR, false, true);
    }

    Console(const Console&);
    Console& operator=(const Console&);
};

inline Console& con() {
    return Console::get();
}


template<class T,class M>
struct StreamExtMT {
    typedef StreamExtMT<T,M> This;    

    M  mutex;       
    T& stream;      

    StreamExtMT(T& stream) : stream(stream)
        { }

private:
    StreamExtMT(This&);
    This& operator=(This&);
};


struct ConsoleNotMT {
    typedef PipeOut::Format Format;                 
    typedef StreamExtMT<PipeIn,MutexInert>  InT;    
    typedef StreamExtMT<PipeOut,MutexInert> OutT;   
    typedef MutexInert::Lock Lock;                  

    InT  in;        
    OutT out;       
    OutT err;       

    static ConsoleNotMT& get()
        { static ConsoleNotMT console(con()); return console; }

private:
    ConsoleNotMT(Console& c) : in(c.in), out(c.out), err(c.err)
        { }

    ConsoleNotMT(const ConsoleNotMT&);
    ConsoleNotMT& operator=(const ConsoleNotMT&);
};


}
#endif