home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / include / strstrem < prev    next >
Text File  |  1998-06-16  |  4KB  |  133 lines
  1. // strstream standard header
  2.  
  3. #if     _MSC_VER > 1000
  4. #pragma once
  5. #endif
  6.  
  7. #ifndef _STRSTREAM_
  8. #define _STRSTREAM_
  9. #include <istream>
  10.  
  11. #ifdef  _MSC_VER
  12. #pragma pack(push,8)
  13. #endif  /* _MSC_VER */
  14. _STD_BEGIN
  15.         // CLASS strstreambuf
  16. class strstreambuf : public streambuf {
  17. public:
  18.     enum __Strstate {_Allocated = 1, _Constant = 2,
  19.         _Dynamic = 4, _Frozen = 8};
  20.     _BITMASK(__Strstate, _Strstate);
  21.     explicit strstreambuf(streamsize _N = 0)
  22.         {_Init(_N); }
  23.     strstreambuf(void *(__cdecl *_A)(size_t),
  24.         void (__cdecl *_F)(void *))
  25.         {_Init(), _Palloc = _A, _Pfree = _F; }
  26.     strstreambuf(char *_G, streamsize _N, char *_P = 0)
  27.         {_Init(_N, _G, _P); }
  28.     strstreambuf(unsigned char *_G, streamsize _N,
  29.         unsigned char *_P = 0)
  30.         {_Init(_N, (char *)_G, (char *)_P); }
  31.     strstreambuf(const char *_G, streamsize _N)
  32.         {_Init(_N, (char *)_G, 0, _Constant); }
  33.     strstreambuf(const unsigned char *_G, streamsize _N)
  34.         {_Init(_N, (char *)_G, 0, _Constant); }
  35.     _CRTIMP virtual ~strstreambuf();
  36.     _CRTIMP void freeze(bool = true);
  37.     char *str()
  38.         {freeze();
  39.         return (gptr()); }
  40.     streamsize pcount() const
  41.         {return (pptr() == 0 ? 0 : pptr() - pbase()); } 
  42.     strstreambuf(signed char *_G, streamsize _N,
  43.         signed char *_P = 0)
  44.         {_Init(_N, (char *)_G, (char *)_P); }
  45.     strstreambuf(const signed char *_G, streamsize _N)
  46.         {_Init(_N, (char *)_G, 0, _Constant); }
  47. protected:
  48.     _CRTIMP virtual int overflow(int = EOF);
  49.     _CRTIMP virtual int pbackfail(int = EOF);
  50.     _CRTIMP virtual int underflow();
  51.     _CRTIMP virtual streampos seekoff(streamoff, ios::seekdir,
  52.         ios::openmode = ios::in | ios::out);
  53.     _CRTIMP virtual streampos seekpos(streampos,
  54.         ios::openmode = ios::in | ios::out);
  55.     _CRTIMP void _Init(int = 0, char * = 0, char * = 0,
  56.         _Strstate = (_Strstate)0);
  57.     _CRTIMP void _Tidy();
  58. private:
  59.     enum {_ALSIZE = 512, _MINSIZE = 32};
  60.     char *_Pendsave, *_Seekhigh;
  61.     int _Alsize;
  62.     _Strstate _Strmode;
  63.     void *(__cdecl *_Palloc)(size_t);
  64.     void (__cdecl *_Pfree)(void *);
  65.     };
  66. _BITMASK_OPS(strstreambuf::__Strstate)
  67.         // CLASS istrstream
  68. class istrstream : public istream {
  69. public:
  70.     explicit istrstream(const char *_S)
  71.         : istream(&_Sb), _Sb(_S, 0) {}
  72.     istrstream(const char *_S, streamsize _N)
  73.         : istream(&_Sb), _Sb(_S, _N) {}
  74.     explicit istrstream(char *_S)
  75.         : istream(&_Sb), _Sb((const char *)_S, 0) {}
  76.     istrstream(char *_S, int _N)
  77.         : istream(&_Sb), _Sb((const char *)_S, _N) {}
  78.     _CRTIMP virtual ~istrstream();
  79.     strstreambuf *rdbuf() const
  80.         {return ((strstreambuf *)&_Sb); }
  81.     char *str()
  82.         {return (_Sb.str()); }
  83. private:
  84.     strstreambuf _Sb;
  85.     };
  86.         // CLASS ostrstream
  87. class ostrstream : public ostream {
  88. public:
  89.     ostrstream()
  90.         : ostream(&_Sb), _Sb() {}
  91.     _CRTIMP ostrstream(char *, streamsize, openmode = out);
  92.     _CRTIMP virtual ~ostrstream();
  93.     strstreambuf *rdbuf() const
  94.         {return ((strstreambuf *)&_Sb); }
  95.     void freeze(bool _F = true)
  96.         {_Sb.freeze(_F); }
  97.     char *str()
  98.         {return (_Sb.str()); }
  99.     streamsize pcount() const
  100.         {return (_Sb.pcount()); }
  101. private:
  102.     strstreambuf _Sb;
  103.     };
  104.         // CLASS strstream
  105. class strstream : public iostream {
  106. public:
  107.     strstream()
  108.         : iostream(&_Sb), _Sb() {}
  109.     _CRTIMP strstream(char *, streamsize, openmode = in | out);
  110.     _CRTIMP virtual ~strstream();
  111.     strstreambuf *rdbuf() const
  112.         {return ((strstreambuf *)&_Sb); }
  113.     void freeze(bool _F = true)
  114.         {_Sb.freeze(_F); }
  115.     char *str()
  116.         {return (_Sb.str()); }
  117.     streamsize pcount() const
  118.         {return (_Sb.pcount()); }
  119. private:
  120.     strstreambuf _Sb;
  121.     };
  122. _STD_END
  123. #ifdef  _MSC_VER
  124. #pragma pack(pop)
  125. #endif  /* _MSC_VER */
  126.  
  127. #endif /* _STRSTREAM_ */
  128.  
  129. /*
  130.  * Copyright (c) 1994 by P.J. Plauger.  ALL RIGHTS RESERVED. 
  131.  * Consult your license regarding permissions and restrictions.
  132.  */
  133.