Return to strstream.h CVS log

Up to [Apple XNU] / GNUtools / libg++ / libio

Annotation of GNUtools/libg++/libio/strstream.h, revision 1.1

1.1     ! root        1: /* This is part of libio/iostream, providing -*- C++ -*- input/output.
        !             2: Copyright (C) 1993 Free Software Foundation
        !             3: 
        !             4: This file is part of the GNU IO Library.  This library is free
        !             5: software; you can redistribute it and/or modify it under the
        !             6: terms of the GNU General Public License as published by the
        !             7: Free Software Foundation; either version 2, or (at your option)
        !             8: any later version.
        !             9: 
        !            10: This library is distributed in the hope that it will be useful,
        !            11: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            13: GNU General Public License for more details.
        !            14: 
        !            15: You should have received a copy of the GNU General Public License
        !            16: along with GNU CC; see the file COPYING.  If not, write to
        !            17: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
        !            18: 
        !            19: As a special exception, if you link this library with files
        !            20: compiled with a GNU compiler to produce an executable, this does not cause
        !            21: the resulting executable to be covered by the GNU General Public License.
        !            22: This exception does not however invalidate any other reasons why
        !            23: the executable file might be covered by the GNU General Public License. */
        !            24: 
        !            25: /* Written by Per Bothner ([email protected]). */
        !            26: 
        !            27: #ifndef __STRSTREAM_H
        !            28: #define __STRSTREAM_H
        !            29: #ifdef __GNUG__
        !            30: #pragma interface
        !            31: #endif
        !            32: #include <iostream.h>
        !            33: #include <strfile.h>
        !            34: 
        !            35: class strstreambuf : public streambuf
        !            36: {
        !            37:   struct _IO_str_fields _s;
        !            38: 
        !            39:     void init_dynamic(_IO_alloc_type alloc, _IO_free_type free,
        !            40:                      int initial_size = 128);
        !            41:     void init_static(char *ptr, int size, char *pstart);
        !            42:     void init_readonly(const char *ptr, int size);
        !            43:   protected:
        !            44:     int is_static() const { return _s._allocate_buffer == (_IO_alloc_type)0; }
        !            45:     virtual int overflow(int = EOF);
        !            46:     virtual int underflow();
        !            47:     virtual int pbackfail(int c);
        !            48:   public:
        !            49:     virtual ~strstreambuf();
        !            50:     strstreambuf() { init_dynamic(0, 0); }
        !            51:     strstreambuf(int initial_size) { init_dynamic(0, 0, initial_size); }
        !            52:     strstreambuf(void *(*alloc)(_IO_size_t), void (*free)(void*))
        !            53:        { init_dynamic(alloc, free); }
        !            54:     strstreambuf(char *ptr, int size, char *pstart = NULL)
        !            55:        { init_static(ptr, size, pstart); }
        !            56:     strstreambuf(unsigned char *ptr, int size, unsigned char *pstart = NULL)
        !            57:        { init_static((char*)ptr, size, (char*)pstart); }
        !            58:     strstreambuf(const char *ptr, int size)
        !            59:        { init_readonly(ptr, size); }
        !            60:     strstreambuf(const unsigned char *ptr, int size)
        !            61:        { init_readonly((const char*)ptr, size); }
        !            62:     strstreambuf(signed char *ptr, int size, signed char *pstart = NULL)
        !            63:        { init_static((char*)ptr, size, (char*)pstart); }
        !            64:     strstreambuf(const signed char *ptr, int size)
        !            65:        { init_readonly((const char*)ptr, size); }
        !            66:     // Note: frozen() is always true if is_static().
        !            67:     int frozen() { return _flags & _IO_USER_BUF ? 1 : 0; }
        !            68:     void freeze(int n=1)
        !            69:        { if (!is_static())
        !            70:            { if (n) _flags |= _IO_USER_BUF; else _flags &= ~_IO_USER_BUF; } }
        !            71:     _IO_ssize_t pcount();
        !            72:     char *str();
        !            73:     virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
        !            74: };
        !            75: 
        !            76: class strstreambase : virtual public ios {
        !            77:   public:
        !            78:     strstreambuf* rdbuf() { return (strstreambuf*)ios::rdbuf(); }
        !            79:   protected:
        !            80:     strstreambase() { }
        !            81:     strstreambase(char *cp, int n, int mode=ios::out);
        !            82: };
        !            83: 
        !            84: class istrstream : public strstreambase, public istream {
        !            85:   public:
        !            86:     istrstream(const char*, int=0);
        !            87: };
        !            88: 
        !            89: class ostrstream : public strstreambase, public ostream {
        !            90:   public:
        !            91:     ostrstream();
        !            92:     ostrstream(char *cp, int n, int mode=ios::out) :strstreambase(cp,n,mode){}
        !            93:     _IO_ssize_t pcount() { return ((strstreambuf*)_strbuf)->pcount(); }
        !            94:     char *str() { return ((strstreambuf*)_strbuf)->str(); }
        !            95:     void freeze(int n = 1) { ((strstreambuf*)_strbuf)->freeze(n); }
        !            96:     int frozen() { return ((strstreambuf*)_strbuf)->frozen(); }
        !            97: };
        !            98: 
        !            99: class strstream : public strstreambase, public iostream {
        !           100:   public:
        !           101:     strstream() : strstreambase() { init(new strstreambuf()); }
        !           102:     strstream(char *cp, int n, int mode=ios::out) :strstreambase(cp,n,mode){}
        !           103:     _IO_ssize_t pcount() { return ((strstreambuf*)_strbuf)->pcount(); }
        !           104:     char *str() { return ((strstreambuf*)_strbuf)->str(); }
        !           105:     void freeze(int n = 1) { ((strstreambuf*)_strbuf)->freeze(n); }
        !           106:     int frozen() { return ((strstreambuf*)_strbuf)->frozen(); }
        !           107: };
        !           108: 
        !           109: #endif /*!__STRSTREAM_H*/

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.