home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 14 / hacker14.iso / programacao / cwin / c.exe / $INSTDIR / include / c++ / backward / strstream < prev    next >
Encoding:
Text File  |  2003-12-15  |  5.5 KB  |  175 lines
  1. // Backward-compat support -*- C++ -*-
  2.  
  3. // Copyright (C) 2001, 2002 Free Software Foundation, Inc.
  4. //
  5. // This file is part of the GNU ISO C++ Library.  This library is free
  6. // software; you can redistribute it and/or modify it under the
  7. // terms of the GNU General Public License as published by the
  8. // Free Software Foundation; either version 2, or (at your option)
  9. // any later version.
  10.  
  11. // This library is distributed in the hope that it will be useful,
  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. // GNU General Public License for more details.
  15.  
  16. // You should have received a copy of the GNU General Public License along
  17. // with this library; see the file COPYING.  If not, write to the Free
  18. // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19. // USA.
  20.  
  21. // As a special exception, you may use this file as part of a free software
  22. // library without restriction.  Specifically, if other files instantiate
  23. // templates or use macros or inline functions from this file, or you compile
  24. // this file and link it with other files to produce an executable, this
  25. // file does not by itself cause the resulting executable to be covered by
  26. // the GNU General Public License.  This exception does not however
  27. // invalidate any other reasons why the executable file might be covered by
  28. // the GNU General Public License.
  29.  
  30. /*
  31.  * Copyright (c) 1998
  32.  * Silicon Graphics Computer Systems, Inc.
  33.  *
  34.  * Permission to use, copy, modify, distribute and sell this software
  35.  * and its documentation for any purpose is hereby granted without fee,
  36.  * provided that the above copyright notice appear in all copies and
  37.  * that both that copyright notice and this permission notice appear
  38.  * in supporting documentation.  Silicon Graphics makes no
  39.  * representations about the suitability of this software for any
  40.  * purpose.  It is provided "as is" without express or implied warranty.
  41.  */
  42.  
  43. // WARNING: The classes defined in this header are DEPRECATED.  This
  44. // header is defined in section D.7.1 of the C++ standard, and it
  45. // MAY BE REMOVED in a future standard revision.  You should use the
  46. // header <sstream> instead.
  47.  
  48. #ifndef __SGI_STL_STRSTREAM
  49. #define __SGI_STL_STRSTREAM
  50.  
  51. #include "backward_warning.h"
  52. #include <iosfwd>
  53. #include <ios>
  54. #include <istream>
  55. #include <ostream>
  56. #include <string>
  57.  
  58. namespace std
  59. {
  60.   // Class strstreambuf, a streambuf class that manages an array of char.
  61.   // Note that this class is not a template.
  62.   class strstreambuf : public basic_streambuf<char, char_traits<char> >
  63.   {
  64.   public:                         
  65.     // Types.
  66.     typedef char_traits<char>              _Traits;
  67.     typedef basic_streambuf<char, _Traits> _Base;
  68.  
  69.   public:  
  70.     // Constructor, destructor
  71.     explicit strstreambuf(streamsize __initial_capacity = 0);
  72.     strstreambuf(void* (*__alloc)(size_t), void (*__free)(void*));
  73.  
  74.     strstreambuf(char* __get, streamsize __n, char* __put = 0);
  75.     strstreambuf(signed char* __get, streamsize __n, signed char* __put = 0);
  76.     strstreambuf(unsigned char* __get, streamsize __n, unsigned char* __put=0);
  77.  
  78.     strstreambuf(const char* __get, streamsize __n);
  79.     strstreambuf(const signed char* __get, streamsize __n);
  80.     strstreambuf(const unsigned char* __get, streamsize __n);
  81.  
  82.     virtual ~strstreambuf();
  83.  
  84.   public:
  85.     void freeze(bool = true);
  86.     char* str();
  87.     int pcount() const;
  88.  
  89.   protected:
  90.     virtual int_type overflow(int_type __c  = _Traits::eof());
  91.     virtual int_type pbackfail(int_type __c = _Traits::eof());
  92.     virtual int_type underflow();
  93.     virtual _Base* setbuf(char* __buf, streamsize __n);
  94.     virtual pos_type seekoff(off_type __off, ios_base::seekdir __dir,
  95.                  ios_base::openmode __mode
  96.                  = ios_base::in | ios_base::out);
  97.     virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode
  98.                  = ios_base::in | ios_base::out);
  99.  
  100.   private:  
  101.     // Dynamic allocation, possibly using _M_alloc_fun and _M_free_fun.
  102.     char* _M_alloc(size_t);
  103.     void  _M_free(char*);
  104.  
  105.     // Helper function used in constructors.
  106.     void _M_setup(char* __get, char* __put, streamsize __n);
  107.  
  108.   private:  
  109.     // Data members.
  110.     void* (*_M_alloc_fun)(size_t);
  111.     void  (*_M_free_fun)(void*);
  112.  
  113.     bool _M_dynamic  : 1;
  114.     bool _M_frozen   : 1;
  115.     bool _M_constant : 1;
  116.   };
  117.  
  118.   // Class istrstream, an istream that manages a strstreambuf.
  119.   class istrstream : public basic_istream<char>
  120.   {
  121.   public:
  122.     explicit istrstream(char*);
  123.     explicit istrstream(const char*);
  124.     istrstream(char* , streamsize);
  125.     istrstream(const char*, streamsize);
  126.     virtual ~istrstream();
  127.  
  128.     strstreambuf* rdbuf() const;
  129.     char* str();
  130.  
  131.   private:
  132.     strstreambuf _M_buf;
  133.   };
  134.  
  135.   // Class ostrstream
  136.   class ostrstream : public basic_ostream<char>
  137.   {
  138.   public:
  139.     ostrstream();
  140.     ostrstream(char*, int, ios_base::openmode = ios_base::out);
  141.     virtual ~ostrstream();
  142.  
  143.     strstreambuf* rdbuf() const;
  144.     void freeze(bool = true);
  145.     char* str();
  146.     int pcount() const;
  147.  
  148.   private:
  149.     strstreambuf _M_buf;
  150.   };
  151.  
  152.   // Class strstream
  153.   class strstream : public basic_iostream<char>
  154.   {
  155.   public:
  156.     typedef char                        char_type;
  157.     typedef char_traits<char>::int_type int_type;
  158.     typedef char_traits<char>::pos_type pos_type;
  159.     typedef char_traits<char>::off_type off_type;
  160.  
  161.     strstream();
  162.     strstream(char*, int, ios_base::openmode = ios_base::in | ios_base::out);
  163.     virtual ~strstream();
  164.  
  165.     strstreambuf* rdbuf() const;
  166.     void freeze(bool = true);
  167.     int pcount() const;
  168.     char* str();
  169.  
  170.   private:
  171.     strstreambuf _M_buf;
  172.   };
  173. } // namespace std
  174. #endif 
  175.