include/strstream

// -*- C++ -*-
//===--------------------------- strstream --------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef _LIBCPP_STRSTREAM
#define _LIBCPP_STRSTREAM

/*
    strstream synopsis

class strstreambuf
    : public basic_streambuf<char>
{
public:
    explicit strstreambuf(streamsize alsize_arg = 0);
    strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
    strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = 0);
    strstreambuf(const char* gnext_arg, streamsize n);

    strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = 0);
    strstreambuf(const signed char* gnext_arg, streamsize n);
    strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg = 0);
    strstreambuf(const unsigned char* gnext_arg, streamsize n);

    strstreambuf(strstreambuf&& rhs);
    strstreambuf& operator=(strstreambuf&& rhs);

    virtual ~strstreambuf();

    void swap(strstreambuf& rhs);

    void freeze(bool freezefl = true);
    char* str();
    int pcount() const;

protected:
    virtual int_type overflow (int_type c = EOF);
    virtual int_type pbackfail(int_type c = EOF);
    virtual int_type underflow();
    virtual pos_type seekoff(off_type off, ios_base::seekdir way,
                             ios_base::openmode which = ios_base::in | ios_base::out);
    virtual pos_type seekpos(pos_type sp,
                             ios_base::openmode which = ios_base::in | ios_base::out);
    virtual streambuf* setbuf(char* s, streamsize n);

private:
    typedef T1 strstate;                // exposition only
    static const strstate allocated;    // exposition only
    static const strstate constant;     // exposition only
    static const strstate dynamic;      // exposition only
    static const strstate frozen;       // exposition only
    strstate strmode;                   // exposition only
    streamsize alsize;                  // exposition only
    void* (*palloc)(size_t);            // exposition only
    void (*pfree)(void*);               // exposition only
};

class istrstream
    : public basic_istream<char>
{
public:
    explicit istrstream(const char* s);
    explicit istrstream(char* s);
    istrstream(const char* s, streamsize n);
    istrstream(char* s, streamsize n);

    virtual ~istrstream();

    strstreambuf* rdbuf() const;
    char *str();

private:
    strstreambuf sb; // exposition only
};

class ostrstream
    : public basic_ostream<char>
{
public:
    ostrstream();
    ostrstream(char* s, int n, ios_base::openmode mode = ios_base::out);

    virtual ~ostrstream();

    strstreambuf* rdbuf() const;
    void freeze(bool freezefl = true);
    char* str();
    int pcount() const;

private:
    strstreambuf sb; // exposition only
};

class strstream
    : public basic_iostream<char>
{
public:
    // Types
    typedef char                        char_type;
    typedef char_traits<char>::int_type int_type;
    typedef char_traits<char>::pos_type pos_type;
    typedef char_traits<char>::off_type off_type;

    // constructors/destructor
    strstream();
    strstream(char* s, int n, ios_base::openmode mode = ios_base::in | ios_base::out);

    virtual ~strstream();

    // Members:
    strstreambuf* rdbuf() const;
    void freeze(bool freezefl = true);
    int pcount() const;
    char* str();

private:
    strstreambuf sb; // exposition only
};

}  // std

*/

#include <__config>
#include <ostream>
#include <istream>

#pragma GCC system_header

_LIBCPP_BEGIN_NAMESPACE_STD

class strstreambuf
    : public streambuf
{
public:
    explicit strstreambuf(streamsize __alsize = 0);
    strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*));
    strstreambuf(char* __gnext, streamsize __n, char* __pbeg = 0);
    strstreambuf(const char* __gnext, streamsize __n);

    strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = 0);
    strstreambuf(const signed char* __gnext, streamsize __n);
    strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = 0);
    strstreambuf(const unsigned char* __gnext, streamsize __n);

#ifdef _LIBCPP_MOVE
    strstreambuf(strstreambuf&& __rhs);
    strstreambuf& operator=(strstreambuf&& __rhs);
#endif

    virtual ~strstreambuf();

    void swap(strstreambuf& __rhs);

    void freeze(bool __freezefl = true);
    char* str();
    int pcount() const;

protected:
    virtual int_type overflow (int_type __c = EOF);
    virtual int_type pbackfail(int_type __c = EOF);
    virtual int_type underflow();
    virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
                             ios_base::openmode __which = ios_base::in | ios_base::out);
    virtual pos_type seekpos(pos_type __sp,
                             ios_base::openmode __which = ios_base::in | ios_base::out);

private:
    typedef unsigned __mode_type;
    static const __mode_type __allocated = 0x01;
    static const __mode_type __constant  = 0x02;
    static const __mode_type __dynamic   = 0x04;
    static const __mode_type __frozen    = 0x08;
    static const streamsize    __default_alsize = 4096;

    __mode_type __strmode_;
    streamsize __alsize_;
    void* (*__palloc_)(size_t);
    void (*__pfree_)(void*);

    void __init(char* __gnext, streamsize __n, char* __pbeg);
};

class istrstream
    : public istream
{
public:
    explicit istrstream(const char* __s)
        : istream(&__sb_), __sb_(__s, 0) {}
    explicit istrstream(char* __s)
        : istream(&__sb_), __sb_(__s, 0) {}
    istrstream(const char* __s, streamsize __n)
        : istream(&__sb_), __sb_(__s, __n) {}
    istrstream(char* __s, streamsize __n)
        : istream(&__sb_), __sb_(__s, __n) {}

#ifdef _LIBCPP_MOVE
    istrstream(istrstream&& __rhs)
        : istream(_STD::move(__rhs)),
          __sb_(_STD::move(__rhs.__sb_))
    {
        istream::set_rdbuf(&__sb_);
    }

    istrstream& operator=(istrstream&& __rhs)
    {
        istream::operator=(_STD::move(__rhs));
        __sb_ = _STD::move(__rhs.__sb_);
        return *this;
    }
#endif

    virtual ~istrstream();

    void swap(istrstream& __rhs)
    {
        istream::swap(__rhs);
        __sb_.swap(__rhs.__sb_);
    }

    strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
    char *str() {return __sb_.str();}

private:
    strstreambuf __sb_;
};

class ostrstream
    : public ostream
{
public:
    ostrstream()
        : ostream(&__sb_) {}
    ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)
        : ostream(&__sb_),
          __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
        {}

#ifdef _LIBCPP_MOVE
    ostrstream(ostrstream&& __rhs)
        : ostream(_STD::move(__rhs)),
          __sb_(_STD::move(__rhs.__sb_))
    {
        ostream::set_rdbuf(&__sb_);
    }

    ostrstream& operator=(ostrstream&& __rhs)
    {
        ostream::operator=(_STD::move(__rhs));
        __sb_ = _STD::move(__rhs.__sb_);
        return *this;
    }
#endif

    virtual ~ostrstream();

    void swap(ostrstream& __rhs)
    {
        ostream::swap(__rhs);
        __sb_.swap(__rhs.__sb_);
    }

    strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
    void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
    char* str()         {return __sb_.str();}
    int pcount() const  {return __sb_.pcount();}

private:
    strstreambuf __sb_; // exposition only
};

class strstream
    : public iostream
{
public:
    // Types
    typedef char                        char_type;
    typedef char_traits<char>::int_type int_type;
    typedef char_traits<char>::pos_type pos_type;
    typedef char_traits<char>::off_type off_type;

    // constructors/destructor
    strstream()
        : iostream(&__sb_) {}
    strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out)
        : iostream(&__sb_),
          __sb_(__s, __n, __s + (__mode & ios::app ? strlen(__s) : 0))
        {}

#ifdef _LIBCPP_MOVE
    strstream(strstream&& __rhs)
        : iostream(_STD::move(__rhs)),
          __sb_(_STD::move(__rhs.__sb_))
    {
        iostream::set_rdbuf(&__sb_);
    }

    strstream& operator=(strstream&& __rhs)
    {
        iostream::operator=(_STD::move(__rhs));
        __sb_ = _STD::move(__rhs.__sb_);
        return *this;
    }
#endif

    virtual ~strstream();

    void swap(strstream& __rhs)
    {
        iostream::swap(__rhs);
        __sb_.swap(__rhs.__sb_);
    }

    // Members:
    strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
    void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
    int pcount() const {return __sb_.pcount();}
    char* str()        {return __sb_.str();}

private:
    strstreambuf __sb_; // exposition only
};

_LIBCPP_END_NAMESPACE_STD

#endif  // _LIBCPP_STRSTREAM