io.h

Go to the documentation of this file.

/*
Copyright (c) 2016 Alexei Novakov
https://github.com/novalexei

Distributed under the Boost Software License, Version 1.0.
http://boost.org/LICENSE_1_0.txt
*/
#ifndef SERVLET_IO_H
#define SERVLET_IO_H

#include <type_traits>
#include <iostream>
#include <vector>

#include <experimental/type_traits>

namespace servlet {

template<std::size_t BufSize>
struct buffering
{
    static constexpr std::size_t buf_size = BufSize;
};

typedef buffering<0>    non_buffered;
typedef buffering<1024> buffer_1k;
typedef buffering<2048> buffer_2k;
typedef buffering<4096> buffer_4k;
typedef buffering<8192> buffer_8k;

struct sink {};
struct source {};
struct buffer_provider {};

template<typename Sink, typename Buffering, typename CharT, typename Traits, typename Category = void>
class basic_outbuf;

template<typename Sink, typename Buffering, typename CharT, typename Traits, typename Category>
class basic_outbuf : public std::basic_streambuf<CharT, Traits>
{
public:
    typedef CharT                     char_type;
    typedef Traits                    traits_type;
    typedef typename Traits::int_type int_type;
    typedef typename Traits::pos_type pos_type;
    typedef typename Traits::off_type off_type;

    typedef std::basic_ostream<char_type, traits_type>  _super_type;

    template<class... Args>
    basic_outbuf(Args &&... args) : _sink{std::forward<Args>(args)...}, _buffer{new CharT[Buffering::buf_size]}
    {
        this->setp(_buffer, _buffer + Buffering::buf_size - 1);
    }

    basic_outbuf(const basic_outbuf& other) = delete;
    basic_outbuf(basic_outbuf&& ) = delete;

    ~basic_outbuf() noexcept override { sync(); delete[] _buffer; }

    basic_outbuf& operator=(const basic_outbuf& ) = delete;
    basic_outbuf& operator=(basic_outbuf&& ) = delete;

    Sink& operator*() { return _sink; }
    Sink* operator->() { return &_sink; }

    const Sink& operator*() const { return _sink; }
    const Sink* operator->() const { return &_sink; }

    void reset() { this->setp(_buffer, _buffer + Buffering::buf_size - 1); }

protected:
    int_type overflow(int_type ch) override
    {
        _buffer[Buffering::buf_size-1] = static_cast<char>(ch);
        this->setp(_buffer, _buffer + Buffering::buf_size - 1);
        return _sink.write(_buffer, Buffering::buf_size) < Buffering::buf_size ? traits_type::eof() : ch;
    }

    int sync() override
    {
        std::size_t size = this->pptr() - _buffer;
        if (size > 0)
        {
            if (_sink.write(_buffer, static_cast<std::streamsize>(size)) < size) return -1;
        }
        _sink.flush();
        this->setp(_buffer, _buffer + Buffering::buf_size - 1);
        return 0;
    }

private:
    Sink _sink;
    CharT *_buffer;
};

template<typename Sink, typename CharT, typename Traits>
class basic_outbuf<Sink, non_buffered, CharT, Traits,
                   typename std::enable_if_t<std::is_same<typename Sink::category, buffer_provider>::value>> :
        public std::basic_streambuf<CharT, Traits>
{
public:
    typedef CharT                     char_type;
    typedef Traits                    traits_type;
    typedef typename Traits::int_type int_type;
    typedef typename Traits::pos_type pos_type;
    typedef typename Traits::off_type off_type;

    typedef std::basic_ostream<char_type, traits_type>  _super_type;

    template<class... Args>
    basic_outbuf(Args &&... args) : _sink{std::forward<Args>(args)...} {}

    basic_outbuf(const basic_outbuf& other) = delete;
    basic_outbuf(basic_outbuf&& ) = delete;

    ~basic_outbuf() noexcept override { sync(); }

    basic_outbuf& operator=(const basic_outbuf& ) = delete;
    basic_outbuf& operator=(basic_outbuf&& ) = delete;

    Sink& operator*() { return _sink; }
    Sink* operator->() { return &_sink; }

    const Sink& operator*() const { return _sink; }
    const Sink* operator->() const { return &_sink; }

    void reset() { this->setp(this->pbase(), this->epptr()); }

protected:
    int_type overflow(int_type ch) override
    {
        *this->pptr() = static_cast<char>(ch);
        std::pair<CharT*, std::size_t> buffer = _sink.get_buffer();
        if (!buffer.first || buffer.second <= 0) return traits_type::eof();
        this->setp(buffer.first, buffer.first + buffer.second - 1);
        return ch;
    }

    int sync() override
    {
        _sink.flush(this->pptr() - this->pbase());
        return 0;
    }

private:
    Sink _sink;
};

template<typename Sink, typename CharT, typename Traits, typename Category>
class basic_outbuf<Sink, non_buffered, CharT, Traits, Category> : public std::basic_streambuf<CharT, Traits>
{
public:
    typedef CharT                     char_type;
    typedef Traits                    traits_type;
    typedef typename Traits::int_type int_type;
    typedef typename Traits::pos_type pos_type;
    typedef typename Traits::off_type off_type;

    template <class... Args>
    basic_outbuf(Args&&... args) : _sink{std::forward<Args>(args)...} {}

    basic_outbuf(const basic_outbuf& ) = default;
    basic_outbuf(basic_outbuf&& ) = default;

    basic_outbuf& operator=(const basic_outbuf& ) = default;
    basic_outbuf& operator=(basic_outbuf&& ) = default;

    void reset() { }

    Sink& operator*() { return _sink; }
    Sink* operator->() { return &_sink; }

    const Sink& operator*() const { return _sink; }
    const Sink* operator->() const { return &_sink; }

protected:
    int_type overflow(int_type ch) override
    {
        char_type tmp_ch = static_cast<char_type>(ch);
        return _sink.write(&tmp_ch, 1) == 1 ? ch : traits_type::eof();
    }

    int sync() override { _sink.flush(); return 0; }

    std::streamsize xsputn(const char_type* s, std::streamsize n) override { return _sink.write(s, n); }

private:
    Sink _sink;
};


template<typename Sink, typename Buffering, typename CharT, typename Traits = std::char_traits<CharT>>
class basic_outstream : public std::basic_ostream<CharT, Traits>
{
    typedef basic_outbuf<Sink, Buffering, CharT, Traits> _outbuf_type;
    typedef std::basic_ostream<CharT, Traits>            _ostream_type;
public:
    typedef CharT                          char_type;
    typedef Traits                         traits_type;
    typedef typename traits_type::int_type int_type;
    typedef typename traits_type::pos_type pos_type;
    typedef typename traits_type::off_type off_type;

    template <class... Args>
    explicit basic_outstream(Args&&... args) : _ostream_type{}
    {
        this->rdbuf(new _outbuf_type{std::forward<Args>(args)...});
    }
    basic_outstream(basic_outstream&& other) : _ostream_type{}
    {
        this->rdbuf(other.rdbuf());
        other.rdbuf(nullptr);
    }
    basic_outstream& operator=(basic_outstream&& other)
    {
        this->rdbuf(other.rdbuf());
        other.rdbuf(nullptr);
        return *this;
    }

    ~basic_outstream() noexcept override { delete this->rdbuf(); }

    Sink& operator*() { return buf()->operator*(); }
    Sink* operator->() { return buf()->operator->(); }

    const Sink& operator*() const { return buf()->operator*(); }
    const Sink* operator->() const { return buf()->operator->(); }

//    void reset_buffer() { return buf()->reset(); }

private:
    inline _outbuf_type *buf() { return static_cast<_outbuf_type*>(this->rdbuf()); }
    inline const _outbuf_type *buf() const { return static_cast<const _outbuf_type*>(this->rdbuf()); }
};

template<typename Source, typename Buffering, typename CharT, typename Traits, typename Enable = void>
class basic_inbuf;

template<typename Source, typename Buffering, typename CharT, typename Traits, typename Enable>
class basic_inbuf : public std::basic_streambuf<CharT, Traits>
{
public:
    typedef CharT                     char_type;
    typedef Traits                    traits_type;
    typedef typename Traits::int_type int_type;
    typedef typename Traits::pos_type pos_type;
    typedef typename Traits::off_type off_type;

    template <class... Args>
    basic_inbuf(Args&&... args) : _source{std::forward<Args>(args)...}, _buffer{new char_type[Buffering::buf_size]} {}

    ~basic_inbuf() noexcept override { delete[] _buffer; }

    basic_inbuf(const basic_inbuf& ) = delete;
    basic_inbuf(basic_inbuf&& other) = delete;

    basic_inbuf& operator=(const basic_inbuf& ) = delete;
    basic_inbuf& operator=(basic_inbuf&& ) = delete;

    Source& operator*() { return _source; }
    Source* operator->() { return &_source; }

    const Source& operator*() const { return _source; }
    const Source* operator->() const { return &_source; }

    void reset() { }

protected:
    int_type underflow() override
    {
        std::streamsize new_size = _source.read(_buffer, Buffering::buf_size);
        if (new_size == 0) return traits_type::eof();
        this->setg(_buffer, _buffer, _buffer + new_size);
        return traits_type::to_int_type(*_buffer);
    }

    int_type pbackfail(int_type ch) override
    {
        if (this->egptr() <= this->eback()) return traits_type::eof();
        this->gbump(-1);
        return ch;
    }

private:
    Source _source;
    CharT *_buffer;
};

template<typename Source, typename CharT, typename Traits>
class basic_inbuf<Source, non_buffered, CharT, Traits,
                  typename std::enable_if_t<std::is_same<typename Source::category, buffer_provider>::value>> :
        public std::basic_streambuf<CharT, Traits>
{
public:
    typedef CharT                     char_type;
    typedef Traits                    traits_type;
    typedef typename Traits::int_type int_type;
    typedef typename Traits::pos_type pos_type;
    typedef typename Traits::off_type off_type;

    template <class... Args>
    basic_inbuf(Args&&... args) : _source{std::forward<Args>(args)...} {}

    ~basic_inbuf() noexcept = default;

    basic_inbuf(const basic_inbuf& ) = delete;
    basic_inbuf(basic_inbuf&& other) = delete;

    basic_inbuf& operator=(const basic_inbuf& ) = delete;
    basic_inbuf& operator=(basic_inbuf&& ) = delete;

    Source& operator*() { return _source; }
    Source* operator->() { return &_source; }

    const Source& operator*() const { return _source; }
    const Source* operator->() const { return &_source; }

    void reset() { this->setg(this->eback(), this->eback(), this->egptr()); }

protected:
    int_type underflow() override
    {
        std::pair<CharT*, std::size_t> buffer = _source.get_buffer();
        if (!buffer.first || buffer.second <= 0) return traits_type::eof();
        this->setg(buffer.first, buffer.first, buffer.first + buffer.second);
        return traits_type::to_int_type(*this->eback());
    }

    int_type pbackfail(int_type ch) override
    {
        if (this->egptr() <= this->eback()) return traits_type::eof();
        this->gbump(-1);
        return ch;
    }

private:
    Source _source;
};

template<typename Source, typename Buffering, typename CharT, typename Traits = std::char_traits<CharT>>
class basic_instream : public std::basic_istream<CharT, Traits>
{
    typedef basic_inbuf<Source, Buffering, CharT, Traits> _inbuf_type;
    typedef std::basic_istream<CharT, Traits>             _istream_type;
public:
    typedef CharT                          char_type;
    typedef Traits                         traits_type;
    typedef typename traits_type::int_type int_type;
    typedef typename traits_type::pos_type pos_type;
    typedef typename traits_type::off_type off_type;

    template <typename... Args>
    explicit basic_instream(Args&&... args) : _istream_type{}
    {
        this->rdbuf(new _inbuf_type{std::forward<Args>(args)...});
    }
    basic_instream(const basic_instream& ) = delete;
    basic_instream(basic_instream&& other) : _istream_type{}
    {
        this->rdbuf(other.rdbuf());
        other.rdbuf(nullptr);
    }

    basic_instream& operator=(basic_instream&& other)
    {
        this->rdbuf(other.rdbuf());
        other.rdbuf(nullptr);
        return *this;
    }

    ~basic_instream() noexcept override { delete this->rdbuf(); }

    Source& operator*() { return buf()->operator*(); }
    Source* operator->() { return buf()->operator->(); }

    const Source& operator*() const { return buf()->operator*(); }
    const Source* operator->() const { return buf()->operator->(); }

//    void reset_buffer() { return buf()->reset(); }
private:
    inline _inbuf_type* buf() { return static_cast<_inbuf_type*>(this->rdbuf()); }
    inline const _inbuf_type* buf() const { return static_cast<const _inbuf_type*>(this->rdbuf()); }
};

template <typename Sink, typename Buffering = non_buffered>
using outstream = basic_outstream<Sink, Buffering, char>;
template <typename Source, typename Buffering = non_buffered>
using instream = basic_instream<Source, Buffering, char>;

} // end of servlet namespace

#endif // SERVLET_IO_H