BufferedStream.h

#pragma once


#include <libutl/Stream.h>
#include <libutl/Vector.h>


UTL_NS_BEGIN;


class BufferedStream;


typedef BufferedStream& (*bsmanip0)(BufferedStream& stream);



class BufferedStream : public Stream
{
    UTL_CLASS_DECL(BufferedStream, Stream);

public:
    BufferedStream(Stream* stream,
                   bool streamOwner = true,
                   size_t iBufSize = KB(16),
                   size_t oBufSize = KB(16))
    {
        init();
        setStream(stream, streamOwner, iBufSize, oBufSize);
    }

    virtual void copy(const Object& rhs);

    virtual void close();


    virtual bool isInput() const;
    virtual void setInput(bool input);
    virtual bool isOutput() const;
    virtual void setOutput(bool output);
    virtual bool eof() const;
    virtual void setEOF(bool eof);
    virtual bool error() const;
    virtual void setError(bool error);

    const Stream*
    getStream() const
    {
        return _stream;
    }

    Stream*
    getStream()
    {
        return _stream;
    }

    void setStream(Stream* stream,
                   bool streamOwner = true,
                   size_t iBufSize = KB(16),
                   size_t oBufSize = KB(16));

    Stream* takeStream();

    bool eofBlocking();

    void
    setMode(uint_t mode, bool p_setBufs = true)
    {
        setInput((mode & io_rd) != 0);
        setOutput((mode & io_wr) != 0);
        if (p_setBufs) setBufs();
    }


    void
    get(byte_t& b)
    {
        ASSERTD(isInput());
        _inCount++;
        if (_iBufPos == _iBufLim) underflow();
        b = _iBuf[_iBufPos++];
    }

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

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

    byte_t peek();

    virtual Stream& readLine(String& str);

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

    void
    unget(byte_t b)
    {
        ASSERTD(_iBufPos > 0);
        _inCount--;
        _iBuf[--_iBufPos] = b;
    }

    void
    unget(char c)
    {
        unget((byte_t)c);
    }



    virtual BufferedStream&
    newline()
    {
        return newline(false);
    }

    BufferedStream&
    newline(bool forceFlush)
    {
        put((byte_t)'\n');
        setBOL(true);
        if (forceFlush || isLineBuffered()) flush();
        return self;
    }

    BufferedStream&
    put(byte_t b)
    {
        ASSERTD(isOutput());
        _outCount++;
        _oBuf[_oBufPos++] = b;
        if (_oBufPos == _oBuf.size()) overflow();
        return self;
    }

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

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

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



    bool
    hasInput() const
    {
        return (_iBufPos < _iBufLim);
    }

    virtual BufferedStream& flush(uint_t mode = io_wr);

    bool
    isLineBuffered() const
    {
        return getFlag(io_lineBuffered);
    }

    void
    setLineBuffered(bool lineBuffered)
    {
        setFlag(io_lineBuffered, lineBuffered);
    }

    void setBufs(size_t iBufSize = KB(16), size_t oBufSize = KB(16));

    void setInputBuf(size_t size = KB(16));

    void setOutputBuf(size_t size = KB(16));


    BufferedStream& operator<<(bsmanip0 manip)
    {
        return manip(self);
    }
    BufferedStream& operator<<(void* ptr)
    {
        static_cast<Stream&>(self) << ptr;
        return self;
    }
    BufferedStream& operator<<(const char* str)
    {
        static_cast<Stream&>(self) << str;
        return self;
    }
    BufferedStream& operator<<(char c)
    {
        static_cast<Stream&>(self) << c;
        return self;
    }
    BufferedStream& operator>>(char& c)
    {
        static_cast<Stream&>(self) >> c;
        return self;
    }
    BufferedStream& operator<<(byte_t b)
    {
        static_cast<Stream&>(self) << b;
        return self;
    }
    BufferedStream& operator>>(byte_t& b)
    {
        static_cast<Stream&>(self) >> b;
        return self;
    }
    BufferedStream& operator<<(short n)
    {
        static_cast<Stream&>(self) << n;
        return self;
    }
    BufferedStream& operator>>(short& n)
    {
        static_cast<Stream&>(self) >> n;
        return self;
    }
    BufferedStream& operator<<(ushort_t n)
    {
        static_cast<Stream&>(self) << n;
        return self;
    }
    BufferedStream& operator>>(ushort_t& n)
    {
        static_cast<Stream&>(self) >> n;
        return self;
    }
    BufferedStream& operator<<(int n)
    {
        static_cast<Stream&>(self) << n;
        return self;
    }
    BufferedStream& operator>>(int& n)
    {
        static_cast<Stream&>(self) >> n;
        return self;
    }
    BufferedStream& operator<<(uint_t n)
    {
        static_cast<Stream&>(self) << n;
        return self;
    }
    BufferedStream& operator>>(uint_t& n)
    {
        static_cast<Stream&>(self) >> n;
        return self;
    }
    BufferedStream& operator<<(long n)
    {
        static_cast<Stream&>(self) << n;
        return self;
    }
    BufferedStream& operator>>(long& n)
    {
        static_cast<Stream&>(self) >> n;
        return self;
    }
    BufferedStream& operator<<(ulong_t n)
    {
        static_cast<Stream&>(self) << n;
        return self;
    }
    BufferedStream& operator>>(ulong_t& n)
    {
        static_cast<Stream&>(self) >> n;
        return self;
    }
#if UTL_SIZEOF_LONG == 4
    BufferedStream& operator<<(int64_t n)
    {
        static_cast<Stream&>(self) << n;
        return self;
    }
    BufferedStream& operator>>(int64_t& n)
    {
        static_cast<Stream&>(self) >> n;
        return self;
    }
    BufferedStream& operator<<(uint64_t n)
    {
        static_cast<Stream&>(self) << n;
        return self;
    }
    BufferedStream& operator>>(uint64_t& n)
    {
        static_cast<Stream&>(self) >> n;
        return self;
    }
#endif
    BufferedStream& operator<<(double n)
    {
        static_cast<Stream&>(self) << n;
        return self;
    }
    BufferedStream& operator>>(double& n)
    {
        static_cast<Stream&>(self) >> n;
        return self;
    }
protected:
    virtual void clear();



    virtual void underflow();



    virtual void overflow();
protected:
    // input buffer
    size_t _iBufPos, _iBufLim;
    Vector<byte_t> _iBuf;

    // output buffer
    size_t _oBufPos;
    Vector<byte_t> _oBuf;

    // buffered stream
    Stream* _stream;

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


inline utl::BufferedStream&
endl(utl::BufferedStream& stream)
{
    return stream.newline(false);
}


inline utl::BufferedStream&
endlf(utl::BufferedStream& stream)
{
    return stream.newline(true);
}


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


UTL_NS_END;


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


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


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