home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / include / sstream < prev    next >
Text File  |  1998-06-16  |  9KB  |  295 lines
  1. // sstream standard header
  2.  
  3. #if     _MSC_VER > 1000
  4. #pragma once
  5. #endif
  6.  
  7. #ifndef _SSTREAM_
  8. #define _SSTREAM_
  9. #include <string>
  10.  
  11. #ifdef  _MSC_VER
  12. #pragma pack(push,8)
  13. #endif  /* _MSC_VER */
  14. _STD_BEGIN
  15. enum __Strstate {_Allocated = 1, _Constant = 2, _Noread = 4};
  16. _BITMASK(__Strstate, _Strstate);
  17. _BITMASK_OPS(__Strstate)
  18.         // TEMPLATE CLASS basic_stringbuf
  19. template<class _E,
  20.     class _Tr = char_traits<_E>,
  21.     class _A = allocator<_E> >
  22.     class basic_stringbuf : public basic_streambuf<_E, _Tr> {
  23. public:
  24.     typedef basic_string<_E, _Tr, _A> _Mystr;
  25.     explicit basic_stringbuf(
  26.         ios_base::openmode _W = ios_base::in | ios_base::out)
  27.         {_Init(0, 0, _Mode(_W)); }
  28.     explicit basic_stringbuf(const _Mystr& _S,
  29.         ios_base::openmode _W = ios_base::in | ios_base::out)
  30.         {_Init(_S.c_str(), _S.size(), _Mode(_W)); }
  31.     virtual ~basic_stringbuf()
  32.         {_Tidy(); }
  33.     _Mystr str() const
  34.         {if (!(_Strmode & _Constant) && pptr() != 0)
  35.             {_Mystr _Str(pbase(), (_Seekhigh < pptr()
  36.                 ? pptr() : _Seekhigh) - pbase());
  37.             return (_Str); }
  38.         else if (!(_Strmode & _Noread) && gptr() != 0)
  39.             {_Mystr _Str(eback(), egptr() - eback());
  40.             return (_Str); }
  41.         else
  42.             {_Mystr _Nul;
  43.             return (_Nul); }}
  44.     void str(const _Mystr& _S)
  45.         {_Tidy();
  46.         _Init(_S.c_str(), _S.size(), _Strmode); }
  47. protected:
  48.     virtual int_type overflow(int_type _C = _Tr::eof())
  49.         {if (_Tr::eq_int_type(_Tr::eof(), _C))
  50.             return (_Tr::not_eof(_C));
  51.         else if (pptr() != 0 && pptr() < epptr())
  52.             {*_Pninc() = _Tr::to_char_type(_C);
  53.             return (_C); }
  54.         else if (_Strmode & _Constant)
  55.             return (_Tr::eof());
  56.         else
  57.             {size_t _Os = gptr() == 0 ? 0 : epptr() - eback();
  58.             size_t _Ns = _Os + _Alsize;
  59.             _E *_P = _Al.allocate(_Ns, (void *)0);
  60.             if (0 < _Os)
  61.                 _Tr::copy(_P, eback(), _Os);
  62.             else if (_ALSIZE < _Alsize)
  63.                 _Alsize = _ALSIZE;
  64.             if (_Strmode & _Allocated)
  65.                 _Al.deallocate(eback(), _Os);
  66.             _Strmode |= _Allocated;
  67.             if (_Os == 0)
  68.                 {_Seekhigh = _P;
  69.                 setp(_P, _P + _Ns);
  70.                 setg(_P, _P, _P); }
  71.             else
  72.                 {_Seekhigh = _Seekhigh - eback() + _P;
  73.                 setp(pbase() - eback() + _P,
  74.                     pptr() - eback() + _P, _P + _Ns);
  75.                 if (_Strmode & _Noread)
  76.                     setg(_P, _P, _P);
  77.                 else
  78.                     setg(_P, gptr() - eback() + _P, pptr() + 1); }
  79.             *_Pninc() = _Tr::to_char_type(_C);
  80.             return (_C); }}
  81.     virtual int_type pbackfail(int_type _C = _Tr::eof())
  82.         {if (gptr() == 0 || gptr() <= eback()
  83.             || !_Tr::eq_int_type(_Tr::eof(), _C)
  84.                 && !_Tr::eq(_Tr::to_char_type(_C), gptr()[-1])
  85.                 && _Strmode & _Constant)
  86.             return (_Tr::eof());
  87.         else
  88.             {gbump(-1);
  89.             if (!_Tr::eq_int_type(_Tr::eof(), _C))
  90.                 *gptr() = _Tr::to_char_type(_C);
  91.             return (_Tr::not_eof(_C)); }}
  92.     virtual int_type underflow()
  93.         {if (gptr() == 0)
  94.             return (_Tr::eof());
  95.         else if (gptr() < egptr())
  96.             return (_Tr::to_int_type(*gptr()));
  97.         else if (_Strmode & _Noread || pptr() == 0
  98.             || pptr() <= gptr() && _Seekhigh <= gptr())
  99.             return (_Tr::eof());
  100.         else
  101.             {if (_Seekhigh < pptr())
  102.                 _Seekhigh = pptr();
  103.             setg(eback(), gptr(), _Seekhigh);
  104.             return (_Tr::to_int_type(*gptr())); }}
  105.     virtual pos_type seekoff(off_type _O, ios_base::seekdir _Way,
  106.         ios_base::openmode _Which = ios_base::in | ios_base::out)
  107.         {if (pptr() != 0 && _Seekhigh < pptr())
  108.             _Seekhigh = pptr();
  109.         if (_Which & ios_base::in && gptr() != 0)
  110.             {if (_Way == ios_base::end)
  111.                 _O += _Seekhigh - eback();
  112.             else if (_Way == ios_base::cur
  113.                 && !(_Which & ios_base::out))
  114.                 _O += gptr() - eback();
  115.             else if (_Way != ios_base::beg)
  116.                 _O = _BADOFF;
  117.             if (0 <= _O && _O <= _Seekhigh - eback())
  118.                 {gbump(eback() - gptr() + _O);
  119.                 if (_Which & ios_base::out && pptr() != 0)
  120.                     setp(pbase(), gptr(), epptr()); }
  121.             else
  122.                 _O = _BADOFF; }
  123.         else if (_Which & ios_base::out && pptr() != 0)
  124.             {if (_Way == ios_base::end)
  125.                 _O += _Seekhigh - eback();
  126.             else if (_Way == ios_base::cur)
  127.                 _O += pptr() - eback();
  128.             else if (_Way != ios_base::beg)
  129.                 _O = _BADOFF;
  130.             if (0 <= _O && _O <= _Seekhigh - eback())
  131.                 pbump(eback() - pptr() + _O);
  132.             else
  133.                 _O = _BADOFF; }
  134.         else
  135.             _O = _BADOFF;
  136.         return (pos_type(_O)); }
  137.     virtual pos_type seekpos(pos_type _P,
  138.         ios_base::openmode _Which = ios_base::in | ios_base::out)
  139.         {streamoff _O = (streamoff)_P;
  140.         if (pptr() != 0 && _Seekhigh < pptr())
  141.             _Seekhigh = pptr();
  142.         if (_O == _BADOFF)
  143.             ;
  144.         else if (_Which & ios_base::in && gptr() != 0)
  145.             {if (0 <= _O && _O <= _Seekhigh - eback())
  146.                 {gbump(eback() - gptr() + _O);
  147.                 if (_Which & ios_base::out && pptr() != 0)
  148.                     setp(pbase(), gptr(), epptr()); }
  149.             else
  150.                 _O = _BADOFF; }
  151.         else if (_Which & ios_base::out && pptr() != 0)
  152.             {if (0 <= _O && _O <= _Seekhigh - eback())
  153.                 pbump(eback() - pptr() + _O);
  154.             else
  155.                 _O = _BADOFF; }
  156.         else
  157.             _O = _BADOFF;
  158.         return (streampos(_O)); }
  159.     void _Init(const _E *_S, size_t _N, _Strstate _M)
  160.         {_Pendsave = 0, _Seekhigh = 0;
  161.         _Alsize = _MINSIZE, _Strmode = _M;
  162.         if (_N == 0 || (_Strmode & (_Noread | _Constant))
  163.             == (_Noread | _Constant))
  164.             {setg(0, 0, 0);
  165.             setp(0, 0); }
  166.         else
  167.             {_E *_P = _Al.allocate(_N, (void *)0);
  168.             _Tr::copy(_P, _S, _N);
  169.             _Seekhigh = _P + _N;
  170.             if (!(_Strmode & _Noread))
  171.                 setg(_P, _P, _P + _N);
  172.             if (!(_Strmode & _Constant))
  173.                 {setp(_P, _P + _N);
  174.                 if (gptr() == 0)
  175.                     setg(_P, _P, _P); }
  176.             _Strmode |= _Allocated; }}
  177.     void _Tidy()
  178.         {if (_Strmode & _Allocated)
  179.             _Al.deallocate(eback(),
  180.                 (pptr() != 0 ? epptr() : egptr()) - eback());
  181.         _Seekhigh = 0;
  182.         _Strmode &= ~_Allocated; }
  183. private:
  184.     enum {_ALSIZE = 512, _MINSIZE = 32};
  185.     _Strstate _Mode(ios_base::openmode _W)
  186.         {_Strstate _St = (_Strstate)0;
  187.         if (!(_W & ios_base::in))
  188.             _St |= _Noread;
  189.         if (!(_W & ios_base::out))
  190.             _St |= _Constant;
  191.         return (_St); }
  192.     _E *_Pendsave, *_Seekhigh;
  193.     int _Alsize;
  194.     _Strstate _Strmode;
  195.     allocator<_E> _Al;
  196.     };
  197.         // TEMPLATE CLASS basic_istringstream
  198. template<class _E,
  199.     class _Tr = char_traits<_E>,
  200.     class _A = allocator<_E> >
  201.     class basic_istringstream : public basic_istream<_E, _Tr> {
  202. public:
  203.     typedef basic_stringbuf<_E, _Tr, _A> _Mysb;
  204.     typedef basic_string<_E, _Tr, _A> _Mystr;
  205.     explicit basic_istringstream(openmode _M = in)
  206.         : basic_istream<_E, _Tr>(&_Sb), _Sb(_M | in) {}
  207.     explicit basic_istringstream(const _Mystr& _S,
  208.         openmode _M = in)
  209.         : basic_istream<_E, _Tr>(&_Sb), _Sb(_S, _M | in) {}
  210.     virtual ~basic_istringstream()
  211.         {}
  212.     _Mysb *rdbuf() const
  213.         {return ((_Mysb *)&_Sb); }
  214.     _Mystr str() const
  215.         {return (_Sb.str()); }
  216.     void str(const _Mystr& _S)
  217.         {_Sb.str(_S); }
  218. private:
  219.     _Mysb _Sb;
  220.     };
  221.         // TEMPLATE CLASS basic_ostringstream
  222. template<class _E,
  223.     class _Tr = char_traits<_E>,
  224.     class _A = allocator<_E> >
  225.     class basic_ostringstream : public basic_ostream<_E, _Tr> {
  226. public:
  227.     typedef basic_stringbuf<_E, _Tr, _A> _Mysb;
  228.     typedef basic_string<_E, _Tr, _A> _Mystr;
  229.     explicit basic_ostringstream(openmode _M = out)
  230.         : basic_ostream<_E, _Tr>(&_Sb), _Sb(_M | out) {}
  231.     explicit basic_ostringstream(const _Mystr& _S,
  232.         openmode _M = out)
  233.         : basic_ostream<_E, _Tr>(&_Sb), _Sb(_S, _M | out) {}
  234.     virtual ~basic_ostringstream()
  235.         {}
  236.     _Mysb *rdbuf() const
  237.         {return ((_Mysb *)&_Sb); }
  238.     _Mystr str() const
  239.         {return (_Sb.str()); }
  240.     void str(const _Mystr& _S)
  241.         {_Sb.str(_S); }
  242. private:
  243.     _Mysb _Sb;
  244.     };
  245.         // TEMPLATE CLASS basic_stringstream
  246. template<class _E,
  247.     class _Tr = char_traits<_E>,
  248.     class _A = allocator<_E> >
  249.     class basic_stringstream : public basic_iostream<_E, _Tr> {
  250. public:
  251.     typedef basic_string<_E, _Tr, _A> _Mystr;
  252.     explicit basic_stringstream(openmode _W = in | out)
  253.         : basic_iostream<_E, _Tr>(&_Sb), _Sb(_W) {}
  254.     explicit basic_stringstream(const _Mystr& _S,
  255.         openmode _W = in | out)
  256.         : basic_iostream<_E, _Tr>(&_Sb), _Sb(_S, _W) {}
  257.     virtual ~basic_stringstream()
  258.         {}
  259.     basic_stringbuf<_E, _Tr, _A> *rdbuf() const
  260.         {return ((basic_stringbuf<_E, _Tr, _A> *)&_Sb); }
  261.     _Mystr str() const
  262.         {return (_Sb.str()); }
  263.     void str(const _Mystr& _S)
  264.         {_Sb.str(_S); }
  265. private:
  266.     basic_stringbuf<_E, _Tr, _A> _Sb;
  267.     };
  268.  
  269.  
  270. #ifdef _DLL
  271. #pragma warning(disable:4231) /* the extern before template is a non-standard extension */
  272. extern template class _CRTIMP basic_stringbuf<char, char_traits<char> >;
  273. extern template class _CRTIMP basic_stringbuf<wchar_t, char_traits<wchar_t> >;
  274. extern template class _CRTIMP basic_istringstream<char, char_traits<char> >;
  275. extern template class _CRTIMP basic_istringstream<wchar_t, char_traits<wchar_t> >;
  276. extern template class _CRTIMP basic_ostringstream<char, char_traits<char> >;
  277. extern template class _CRTIMP basic_ostringstream<wchar_t, char_traits<wchar_t> >;
  278. extern template class _CRTIMP basic_stringstream<char, char_traits<char> >;
  279. extern template class _CRTIMP basic_stringstream<wchar_t, char_traits<wchar_t> >;
  280. #pragma warning(default:4231) /* restore previous warning */
  281. #endif        // _DLL
  282.  
  283.  
  284. _STD_END
  285. #ifdef  _MSC_VER
  286. #pragma pack(pop)
  287. #endif  /* _MSC_VER */
  288.  
  289. #endif /* _SSTREAM_ */
  290.  
  291. /*
  292.  * Copyright (c) 1994 by P.J. Plauger.  ALL RIGHTS RESERVED. 
  293.  * Consult your license regarding permissions and restrictions.
  294.  */
  295.