Stream.h

#pragma once


#include <libutl/Exception.h>


UTL_NS_BEGIN;


class String;


enum ios_flg_t
{
    io_eof = 3,         
    io_error = 4,       
    io_bol = 5,         
    io_lineBuffered = 6 
};


typedef Stream& (*smanip0)(Stream& stream);



class Stream : public Object, protected FlagsMI
{
    UTL_CLASS_DECL_ABC(Stream, Object);

public:
    virtual void copy(const Object& rhs);

    virtual void close() = 0;



    bool
    isOwner() const
    {
        return getFlag(flg_owner);
    }

    void
    setOwner(bool owner)
    {
        setFlag(flg_owner, owner);
    }

    size_t
    getInputCount() const
    {
        return _inCount;
    }

    size_t
    getOutputCount() const
    {
        return _outCount;
    }

    uint_t
    getMode() const
    {
        uint_t res = 0;
        if (isInput()) res |= io_rd;
        if (isOutput()) res |= io_wr;
        return res;
    }

    const String& getName() const;

    const String* getNamePtr() const;

    void setName(const String& name);

    void setName(String* name);

    virtual bool isBOL() const;

    virtual void setBOL(bool p_bol);

    virtual bool isInput() const;

    virtual void setInput(bool input);

    virtual bool isOutput() const;

    virtual void setOutput(bool output);

    bool
    isRDWR() const
    {
        return (isInput() && isOutput());
    }

    void
    setBase(uint_t base)
    {
        _base = base;
    }

    void
    setMode(uint_t mode)
    {
        setInput((mode & io_rd) != 0);
        setOutput((mode & io_wr) != 0);
    }



    uint_t
    getIndent() const
    {
        return _indent;
    }

    void
    setIndent(uint_t indent)
    {
        _indent = indent;
    }

    void
    indent(uint_t num = 4)
    {
        _indent += num;
    }

    void
    unindent(uint_t num = 4)
    {
        if (num > _indent)
            _indent = 0;
        else
            _indent -= num;
    }



    void checkOK();

    void clearEOF();

    void clearError();

    virtual bool eof() const;

    virtual void setEOF(bool p_eof);

    virtual bool error() const;

    virtual void setError(bool p_error);

    bool ok() const;



    size_t copyData(Stream& in, size_t numBytes = size_t_max, size_t bufSize = KB(4));

    void
    get(byte_t& b)
    {
        read(&b, 1);
    }

    void
    get(char& c)
    {
        get((byte_t&)c);
    }

    byte_t
    get()
    {
        byte_t b;
        get(b);
        return b;
    }

    bool
    getBit()
    {
        if (_bitMask == 0x80) get(_bitByte);
        bool res = ((_bitByte & _bitMask) != 0);
        _bitMask >>= 1;
        if (_bitMask == 0) _bitMask = 0x80;
        return res;
    }

    uint32_t
    getBits(uint_t numBits)
    {
        ASSERTD(numBits <= 32);
        uint32_t res = 0, mask = 1 << (numBits - 1);
        while (mask != 0)
        {
            if (getBit()) res |= mask;
            mask >>= 1;
        }
        return res;
    }

    virtual Stream& readLine(String& str);

    virtual size_t read(byte_t* array, size_t maxBytes, size_t minBytes = size_t_max) = 0;



    Stream&
    put(byte_t b)
    {
        ASSERTD(isOutput());
        write(&b, 1);
        return self;
    }

    Stream&
    put(char c)
    {
        if (c == '\n')
            return newline();
        else
        {
            indentIfBOL();
            return put((byte_t)c);
        }
    }

    Stream&
    put(int c)
    {
        return put((byte_t)c);
    }

    Stream& put(const char* str);

    Stream& put(const char* str, size_t len);

    Stream&
    putBit(bool b)
    {
        if (b) _bitByte |= _bitMask;
        _bitMask >>= 1;
        if (!_bitMask)
        {
            put(_bitByte);
            _bitMask = 0x80;
            _bitByte = 0;
        }
        return self;
    }

    Stream&
    putBits()
    {
        while (_bitMask != 0x80) putBit(false);
        return self;
    }

    Stream&
    putBits(uint32_t n, uint_t numBits)
    {
        uint32_t mask = 1 << (numBits - 1);
        while (mask != 0)
        {
            putBit((n & mask) != 0);
            mask >>= 1;
        }
        return self;
    }

    virtual Stream&
    newline()
    {
        put((byte_t)'\n');
        setBOL(true);
        return self;
    }

    Stream&
    putLine(const char* str)
    {
        put(str);
        return newline();
    }

    void writeSpaces(size_t num);

    virtual void write(const byte_t* array, size_t num) = 0;

    virtual Stream&
    flush(uint_t mode = io_wr)
    {
        return self;
    }



    Stream& operator<<(smanip0 manip)
    {
        return manip(self);
    }

    Stream& operator<<(void* ptr);

    Stream& operator<<(const char* str);

    // char
    Stream& operator<<(char c)
    {
        put(c);
        return self;
    }
    Stream& operator>>(char& c)
    {
        get(c);
        return self;
    }

    // byte
    Stream& operator<<(byte_t b)
    {
        put(b);
        return self;
    }
    Stream& operator>>(byte_t& b)
    {
        get(b);
        return self;
    }

    // int16_t
    Stream& operator<<(int16_t n);
    Stream& operator>>(int16_t& n);

    // uint16_t
    Stream& operator<<(uint16_t n);
    Stream& operator>>(uint16_t& n);

    // int32_t
    Stream& operator<<(int32_t n);
    Stream& operator>>(int32_t& n);

    // uint32_t
    Stream& operator<<(uint32_t n);
    Stream& operator>>(uint32_t& n);

    // long
    Stream& operator<<(long n);
    Stream& operator>>(long& n);

    // ulong_t
    Stream& operator<<(ulong_t n);
    Stream& operator>>(ulong_t& n);

#if UTL_SIZEOF_LONG == 4
    // int64_t
    Stream& operator<<(int64_t n);
    Stream& operator>>(int64_t& n);

    // uint64_t
    Stream& operator<<(uint64_t n);
    Stream& operator>>(uint64_t& n);
#endif

    // double
    Stream& operator<<(double n);
    Stream& operator>>(double& n);

    static void utl_init();

protected:
    virtual void clear();



    inline void
    indentIfBOL()
    {
        if (!isBOL()) return;
        setBOL(false);
        _indentIfBOL();
    }

    void
    _indentIfBOL()
    {
        uint_t indent = _indent;
        while (indent > 256)
        {
            write(spaces, 256);
            indent -= 256;
        }
        write(spaces, indent);
    }



    void throwStreamEOFex();

    void throwStreamErrorEx();



    void readToken(char* buf, size_t size);

    void readUntilWS(char* buf, size_t size);

    byte_t skipWS();

    // track # input/output bytes
    size_t _inCount;
    size_t _outCount;
    // bit i/o
    byte_t _bitMask;
    byte_t _bitByte;

private:
    static byte_t spaces[256];
    enum flg_t
    {
        flg_owner
    };

private:
    void init();
    void deInit();

private:
    String* _name;
    uint_t _base;
    uint_t _indent;
};


inline utl::Stream&
endl(utl::Stream& stream)
{
    return stream.put('\n');
}


inline utl::Stream&
endlf(utl::Stream& stream)
{
    stream.newline();
    return stream.flush();
}


inline utl::Stream&
flush(utl::Stream& stream)
{
    return stream.flush();
}


UTL_NS_END;


utl::Stream& operator<<(utl::Stream& lhs, const utl::Object& rhs);


utl::Stream& operator>>(utl::Stream& lhs, utl::String& rhs);


utl::Stream& operator<<(utl::Stream& lhs, const utl::String& rhs);