charstream.h

/*****************************************************/
/* lean Strings                 (c) Tobias Zirr 2011 */
/*****************************************************/

#ifndef LEAN_STRINGS_CHARSTREAM
#define LEAN_STRINGS_CHARSTREAM

#include "../lean.h"
#include <iostream>

namespace lean
{
namespace strings
{

template < class Elem, class Traits = std::char_traits<Elem> >
class basic_charbuf : public std::basic_streambuf<Elem, Traits>
{
protected:
    virtual void __CLR_OR_THIS_CALL _Lock() { }
    virtual void __CLR_OR_THIS_CALL _Unlock() { }

public:
    basic_charbuf(char_type *begin, char_type *end)
    {
        setp(begin, end);
        setg(begin, begin, end);
    }

    void reset()
    {
        setp(pbase(), epptr());
        setg(eback(), eback(), egptr());
    }

    char_type* begin() const { return pbase(); }
    char_type* end() const { return epptr(); }
    char_type* write_end() const { return pptr(); }
    char_type* read_end() const { return gptr(); }

};

namespace impl
{
    template < class Elem, class Traits = std::char_traits<Elem> >
    class charbuf_holder
    {
    protected:
        typedef basic_charbuf<Elem, Traits> stream_buffer;
        stream_buffer m_buffer;

        charbuf_holder(typename stream_buffer::char_type *begin, typename stream_buffer::char_type *end)
            : m_buffer(begin, end) { }
    };
}

template < class Elem, class Traits = std::char_traits<Elem> >
class basic_charstream : private impl::charbuf_holder<Elem, Traits>, public std::basic_iostream<Elem, Traits>
{
private:
    typedef impl::charbuf_holder<char_type, traits_type> holder_base_type;
    typedef std::basic_iostream<char_type, traits_type> stream_base_type;

public:
    typedef typename holder_base_type::stream_buffer stream_buffer;

    basic_charstream(char_type *begin, char_type *end)
            : holder_base_type(begin, end),
            stream_base_type(&m_buffer) { }
    basic_charstream(char_type *begin)
            : holder_base_type(begin, begin + std::numeric_limits<int>::max()), // required to be int
            stream_base_type(&m_buffer) { }

    basic_charstream& reset()
    {
        m_buffer.reset();
        return *this;
    }

    stream_buffer* rdbuf() const { return static_cast<stream_buffer*>(stream_base_type::rdbuf()); }

    char_type* begin() const { return m_buffer.begin(); }
    char_type* end() const { return m_buffer.end(); }
    char_type* write_end() const { return m_buffer.write_end(); }
    char_type* read_end() const { return m_buffer.read_end(); }

};

typedef basic_charstream<char> charstream;
typedef basic_charstream<wchar_t> wcharstream;

} // namespace

using strings::basic_charbuf;

using strings::basic_charstream;
using strings::charstream;
using strings::wcharstream;

} // namespace

#endif