home *** CD-ROM | disk | FTP | other *** search
/ PC Format (South-Africa) 2001 May / PCFMay2001.iso / Xenon / C++ / FreeCommandLineTools.exe / Include / sstream.cc < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-31  |  20.1 KB  |  720 lines
  1. #ifndef __SSTREAM_CC
  2. #define __SSTREAM_CC
  3. #pragma option push -b -a8 -pc -Vx- -Ve- -w-inl -w-aus -w-sig
  4. /***************************************************************************
  5.  *
  6.  * sstream.cc - Declarations for the Standard Library basic strings
  7.  *
  8.  ***************************************************************************
  9.  *
  10.  * Copyright (c) 1994-1999 Rogue Wave Software, Inc.  All Rights Reserved.
  11.  *
  12.  * This computer software is owned by Rogue Wave Software, Inc. and is
  13.  * protected by U.S. copyright laws and other laws and by international
  14.  * treaties.  This computer software is furnished by Rogue Wave Software,
  15.  * Inc. pursuant to a written license agreement and may be used, copied,
  16.  * transmitted, and stored only in accordance with the terms of such
  17.  * license and with the inclusion of the above copyright notice.  This
  18.  * computer software or any other copies thereof may not be provided or
  19.  * otherwise made available to any other person.
  20.  *
  21.  * U.S. Government Restricted Rights.  This computer software is provided
  22.  * with Restricted Rights.  Use, duplication, or disclosure by the
  23.  * Government is subject to restrictions as set forth in subparagraph (c)
  24.  * (1) (ii) of The Rights in Technical Data and Computer Software clause
  25.  * at DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the
  26.  * Commercial Computer Software รป Restricted Rights at 48 CFR 52.227-19,
  27.  * as applicable.  Manufacturer is Rogue Wave Software, Inc., 5500
  28.  * Flatiron Parkway, Boulder, Colorado 80301 USA.
  29.  *
  30.  **************************************************************************/
  31.  
  32. #ifndef _RWSTD_NO_NAMESPACE
  33. namespace std {
  34. #endif
  35.  
  36.   /*
  37.    * basic_stringbuf(basic_ios::openmode)
  38.    */
  39.  
  40.   template<class charT, class traits, class Allocator>
  41.   basic_stringbuf<charT, traits, Allocator>::
  42.   basic_stringbuf( ios_base::openmode which)
  43.   : basic_streambuf<charT, traits>()
  44.   , __data(0)
  45.   , __length(0)
  46.   , __end_pos(0)
  47.   {
  48.     this->setp(0,0);
  49.     this->setg(0,0,0);
  50.     basic_streambuf<charT,traits>::mode_ = which;
  51.   }
  52.  
  53.   /*
  54.    * basic_stringbuf(const basic_string, ios_base::openmode)
  55.    */
  56.  
  57.   template<class charT, class traits, class Allocator>
  58.   basic_stringbuf<charT, traits, Allocator>::
  59.   basic_stringbuf(const string_type& s, ios_base::openmode which)
  60.   : basic_streambuf<charT, traits>()
  61.   , __length(s.length())
  62.   {
  63.     basic_streambuf<charT,traits>::mode_ = which;
  64.  
  65.     __data = new charT[__length];
  66.  
  67.     if(s.data())
  68.       traits::copy(__data, s.data(), __length);
  69.  
  70.     if(which & ios_base::in)
  71.       this->setg(__data, __data, __data+__length);
  72.  
  73.     if(which & ios_base::out)
  74.       this->setp(__data, __data+__length);
  75.  
  76.     if(which & ( ios_base::app | ios_base::ate ) )
  77.       pbump(__length);
  78.  
  79.     __end_pos = __length;
  80.  
  81.   }
  82.  
  83.   /*
  84.    * virtual ~basic_stringbuf()
  85.    */
  86.  
  87.   template<class charT, class traits, class Allocator>
  88.   basic_stringbuf<charT, traits, Allocator>::~basic_stringbuf()
  89.   {
  90.     if ( __data )
  91.       delete [] __data;
  92.   }
  93.  
  94.   /*
  95.    * basic_string str() const
  96.    */
  97.  
  98.   template<class charT, class traits, class Allocator>
  99.   basic_string<charT, traits, Allocator>
  100.   basic_stringbuf<charT, traits, Allocator>::str() const
  101.   {
  102.  
  103.     if ( __end_pos == 0 )  return string_type();
  104.  
  105.     if ( (__end_pos > ( this->pptr() - this->pbase() )) && (__end_pos > ( this->egptr() - this->eback() )) )
  106.       return string_type(__data, __end_pos);
  107.     else 
  108.     {
  109.       if ( ( this->pptr() - this->pbase() ) > ( this->egptr() - this->eback() ) )
  110.         return string_type(__data, this->pptr() - this->pbase() );
  111.       else
  112.         return string_type(__data, this->egptr() - this->eback() );
  113.     }
  114.    
  115.   }
  116.  
  117.   /*
  118.    * void str(const basic_string&)
  119.    */
  120.  
  121.   template<class charT, class traits, class Allocator>
  122.   void 
  123.   basic_stringbuf<charT, traits, Allocator>::
  124.   str(const string_type& s)
  125.   {
  126.     if ( __data )
  127.       delete [] __data;
  128.  
  129.     __length = s.length();
  130.  
  131.     if(__length == 0)
  132.     {
  133.       this->setg(0,0,0);
  134.       this->setp(0,0);
  135.       __data = 0;
  136.       return;
  137.     }
  138.  
  139.     __data = new charT[__length];
  140.  
  141.     if(s.data())
  142.       traits::copy(__data, s.data(), __length);
  143.     
  144.     if(basic_streambuf<charT,traits>::mode_ & ios_base::in)
  145.       this->setg(__data, __data, __data+__length);
  146.  
  147.     if(basic_streambuf<charT,traits>::mode_ & ios_base::out)
  148.     {
  149.       this->setp(__data, __data+__length);
  150.       if( (basic_streambuf<charT,traits>::mode_ & ios_base::app) || (basic_streambuf<charT,traits>::mode_ & ios_base::ate ) )
  151.         this->pbump(__length); 
  152.     } 
  153.  
  154.     __end_pos = __length;
  155.   }
  156.   /*
  157.    * int_type overflow(int_type)
  158.    */
  159.  
  160.   template<class charT, class traits, class Allocator>
  161.   _TYPENAME basic_stringbuf<charT, traits, Allocator>::int_type
  162.   basic_stringbuf<charT, traits, Allocator>::overflow(int_type c)
  163.   {
  164.     if((basic_streambuf<charT,traits>::mode_ & ios_base::out) == 0) {
  165.       return traits::eof();
  166.     }
  167.   
  168.     charT        *temp;
  169.     int          old_numb_of_elements,new_numb_of_elements;
  170.     const int    increment=128;
  171.     int_type     var;
  172.  
  173.     if (this->pptr())
  174.     {
  175.       old_numb_of_elements = this->pptr() - __data;
  176.       new_numb_of_elements = old_numb_of_elements + increment;
  177.       temp = new charT[new_numb_of_elements];
  178.  
  179.       traits::copy(temp, __data, old_numb_of_elements);   
  180.       this->setp (temp,temp+new_numb_of_elements);
  181.       this->pbump(old_numb_of_elements);  
  182.      
  183.       charT *tmp=temp+(this->gptr()-this->eback()); 
  184.       this->setg(temp, tmp, this->pptr()+1);
  185.  
  186.       delete [] __data;
  187.       __data = temp;
  188.     }
  189.     else
  190.     {
  191.       new_numb_of_elements=increment;
  192.       temp = new charT[new_numb_of_elements];
  193.       this->setp(temp,temp+new_numb_of_elements);
  194.  
  195.       if((basic_streambuf<charT,traits>::mode_ & ios_base::in) != 0)
  196.         this->setg(temp, temp , temp);
  197.  
  198.       __data =temp; 
  199.     }
  200.   
  201.     if ( traits::eq_int_type(c,traits::eof()) ) var = traits::not_eof(c);
  202.     else
  203.       var = sputc(c);
  204.  
  205.     if ( (this->pptr() - this->pbase()) > __end_pos )
  206.       __end_pos = this->pptr() - this->pbase(); 
  207.  
  208.     return var;
  209.   }
  210.  
  211.   /*
  212.    * int_type pbackfail(int_type)
  213.    */
  214.  
  215.   template<class charT, class traits, class Allocator>
  216.   _TYPENAME basic_stringbuf<charT, traits, Allocator>::int_type
  217.   basic_stringbuf<charT, traits, Allocator>::pbackfail(int_type c)
  218.   {
  219.   
  220.     if ( (!traits::eq_int_type(c,traits::eof())) && (this->gptr()>this->eback()) )
  221.     {
  222.  
  223.       if ( traits::eq(*(this->gptr()-1),traits::to_char_type(c)) ) 
  224.       {
  225.         this->gbump(-1);
  226.         return c;
  227.       }
  228.       else
  229.       {
  230.         if( basic_streambuf<charT,traits>::mode_ & ios_base::out )
  231.         {
  232.           this->gbump(-1);
  233.           *this->gptr()=traits::to_char_type(c);
  234.           return c;
  235.         }
  236.       }
  237.     }       
  238.  
  239.     if ( (traits::eq_int_type(c,traits::eof())) && (this->gptr()>this->eback()) )
  240.     { 
  241.       this->gbump(-1);
  242.       return traits::not_eof(c);
  243.     }
  244.     return traits::eof();
  245.   }
  246.   /*
  247.    * basic_streambuf<charT,traits>* setbuf(char_type* s, streamsize n)
  248.    */
  249.  
  250.   template<class charT, class traits, class Allocator>
  251.   basic_streambuf<charT, traits>*
  252.   basic_stringbuf<charT, traits, Allocator>::setbuf(char_type* s, streamsize n)
  253.   {
  254.     if((basic_streambuf<charT,traits>::mode_ & ios_base::out) != 0)
  255.     {
  256.       if ( n > ( this->pptr() - this->pbase() ) )
  257.       {
  258.         if ( s == 0 ) s = new charT[n];
  259.  
  260.         if ( s )
  261.         {
  262.           int          old_numb_of_elements;
  263.  
  264.           if (this->pptr())
  265.           {
  266.             old_numb_of_elements = this->pptr() - __data;
  267.             traits::copy(s, __data, old_numb_of_elements);   
  268.             this->setp (s,s+n-1);
  269.             this->pbump(old_numb_of_elements);  
  270.  
  271.             charT *tmp=s+(this->gptr()-this->eback()); 
  272.             this->setg(s, tmp, this->pptr()+1);
  273.  
  274.             delete [] __data;
  275.             __data = s;
  276.           }
  277.           else
  278.           {
  279.             this->setp(s,s+n-1);
  280.             if((basic_streambuf<charT,traits>::mode_ & ios_base::in) != 0)
  281.               this->setg(s, s , s);
  282.             __data =s; 
  283.           }
  284.         }
  285.         else
  286.           return (basic_streambuf<charT,traits>*)(0);
  287.       }
  288.       else
  289.         return (basic_streambuf<charT,traits>*)(0);
  290.     }
  291.     return (basic_streambuf<charT,traits>*)(this);
  292.   }
  293.  
  294.   /*
  295.    * int_type underflow()
  296.    */
  297.  
  298.   template<class charT, class traits, class Allocator>
  299.   _TYPENAME basic_stringbuf<charT, traits, Allocator>::int_type
  300.   basic_stringbuf<charT, traits, Allocator>::underflow()
  301.   {
  302.     if(this->gptr() && (this->gptr()<this->egptr()) ) return traits::to_int_type(*this->gptr());
  303.  
  304.     if(((this->pptr() != 0) && ( (this->pptr() > this->egptr()) || ( __end_pos > (this->egptr() - this->eback()) ) ) ) && (!this->gptr())) 
  305.     {
  306.       if ( __end_pos > ( this->pptr() - this->pbase() ) )
  307.         this->setg(this->pbase(), this->pbase(), this->pbase()+__end_pos );
  308.       else     
  309.         this->setg(this->pbase(), this->pbase(), this->pptr());
  310.       return traits::to_int_type(*this->gptr());
  311.     }
  312.  
  313.     if((this->pptr() != 0) && ( (this->pptr() > this->egptr()) || ( __end_pos > ( this->egptr() - this->eback() )) ) ) 
  314.     {
  315.       if ( __end_pos > ( this->pptr() - this->pbase() ) )
  316.         this->setg(this->eback(),this->gptr(),this->eback()+__end_pos);
  317.       else
  318.         this->setg(this->eback(), this->gptr(), this->pptr());
  319.       return traits::to_int_type(*this->gptr());
  320.     }
  321.     return traits::eof();
  322.   }
  323.  
  324.   /*
  325.    * pos_type seekoff(off_type, ios_base::seekdir, ios_base::openmode)
  326.    */
  327.  
  328.   template<class charT, class traits, class Allocator>
  329.   _TYPENAME basic_stringbuf<charT, traits, Allocator>::pos_type
  330.   basic_stringbuf<charT, traits, Allocator>::
  331.   seekoff(off_type off, ios_base::seekdir way, ios_base::openmode which)
  332.   {
  333.     streamsize       newoff;
  334.   
  335.     if((which & ios_base::in) && (which & ios_base::out))
  336.     {
  337.       if ( (way==ios_base::beg) || (way==ios_base::end) )
  338.       {
  339.         if ( seekoff(off,way,ios_base::out) == pos_type(off_type(-1)) )
  340.           return pos_type(off_type(-1));
  341.         return seekoff(off,way,ios_base::in);
  342.       }
  343.       else
  344.         return pos_type(off_type(-1)); 
  345.     }
  346.   
  347.     if((which & ios_base::in) && (this->gptr()!=0))
  348.     {
  349.       if ( (this->egptr() - this->eback()) > __end_pos )
  350.         __end_pos = this->egptr() - this->eback(); 
  351.  
  352.       if ( (this->pptr() - this->pbase()) > __end_pos )
  353.         __end_pos = this->pptr() - this->pbase(); 
  354.  
  355.       if(way == ios_base::beg)
  356.         newoff = 0;
  357.       if(way == ios_base::cur)
  358.         newoff = this->gptr() - this->eback();
  359.       if(way == ios_base::end)
  360.         newoff = __end_pos;
  361.  
  362.       if ( newoff<0 )  return pos_type(off_type(-1)); 
  363.  
  364.       if ( ((this->eback()+long(newoff)+long(off))> this->egptr()) || ((newoff+off)< 0) )
  365.         return pos_type(-1);
  366.  
  367.       this->setg(this->eback(), this->eback() + long(newoff) + long(off), this->egptr());
  368.       return pos_type(newoff+off);
  369.     }
  370.  
  371.     if((which & ios_base::in) && (this->gptr()==0) && (this->egptr()==0) && (this->eback()==0) ) 
  372.       return pos_type(0);
  373.  
  374.     if((which & ios_base::out) && (this->pptr()!=0) && !(basic_streambuf<charT,traits>::mode_ & ios_base::app) )
  375.     {
  376.  
  377.       if ( (this->egptr() - this->eback()) > __end_pos )
  378.         __end_pos = this->egptr() - this->eback(); 
  379.  
  380.       if ( (this->pptr() - this->pbase()) > __end_pos )
  381.         __end_pos = this->pptr() - this->pbase(); 
  382.  
  383.       if(way == ios_base::beg)
  384.         newoff = 0;
  385.       if(way == ios_base::cur)
  386.         newoff = this->pptr() - this->pbase();
  387.       if(way == ios_base::end)
  388.         newoff = __end_pos;
  389.  
  390.       if ( (this->pptr() - this->pbase()) > __end_pos ) __end_pos = this->pptr() - this->pbase();
  391.  
  392.       if ( ((newoff+off)<0) || ((this->pbase()+long(newoff)+long(off))> this->epptr()) )
  393.         return pos_type(off_type(-1));   
  394.  
  395.       this->pbump( newoff+off-(this->pptr()-this->pbase())  );
  396.  
  397.       if (this->eback() !=0 && this->gptr()<=this->pptr() )
  398.         this->setg(this->eback(),this->gptr(),this->pptr());
  399.       else
  400.       {
  401.         if ( (basic_streambuf<charT,traits>::mode_ & ios_base::out  ) &&
  402.              !(basic_streambuf<charT,traits>::mode_ & ios_base::in ) )
  403.           this->setg(this->pbase(),this->pptr(),this->pptr());
  404.       } 
  405.       return pos_type(newoff+off);
  406.     }
  407.     else 
  408.     {
  409.       if ( basic_streambuf<charT,traits>::mode_ & ios_base::app )
  410.         return pos_type(this->pptr()-this->pbase());
  411.  
  412.       if((which & ios_base::out) && (this->pptr()==0) && (this->epptr()==0) && (this->pbase()==0) )
  413.         return pos_type(0);
  414.     }
  415.     return pos_type(off_type(-1));
  416.   }
  417.  
  418.   /*
  419.    * pos_type seekpos(pos_type, ios_base::openmode)
  420.    */
  421.  
  422.   template<class charT, class traits, class Allocator>
  423.   _TYPENAME basic_stringbuf<charT, traits, Allocator>::pos_type
  424.   basic_stringbuf<charT, traits, Allocator>::
  425.   seekpos(pos_type sp, ios_base::openmode which)
  426.   {
  427.     streamsize    newoff = sp;
  428.  
  429.     if((which & ios_base::in) && (which & ios_base::out))
  430.     {
  431.       if ( seekpos(sp,ios_base::out) == pos_type(off_type(-1)) )
  432.         return pos_type(off_type(-1));
  433.       return seekpos(sp,ios_base::in);
  434.     }
  435.  
  436.     if((which & ios_base::in) && (this->gptr()!=0))
  437.     {
  438.     
  439.       if ( newoff<0 )  return pos_type(off_type(-1));
  440.       if ( (this->eback()+long(newoff))> this->egptr() ) return pos_type(off_type(-1));
  441.  
  442.       this->setg(this->eback(), this->eback() + long(newoff), this->egptr());
  443.       return pos_type(newoff);
  444.     }
  445.     if((which & ios_base::out) && (this->pptr()!=0) && !(basic_streambuf<charT,traits>::mode_ & ios_base::app) )
  446.     {
  447.       if ( (newoff<0) || ((this->pbase()+long(newoff))> this->epptr()) )
  448.         return pos_type(off_type(-1)); 
  449.  
  450.       if ( (this->pptr() - this->pbase()) > __end_pos ) __end_pos = this->pptr() - this->pbase();
  451.       this->pbump( newoff-(this->pptr()-this->pbase())  );
  452.  
  453.       if (this->eback() !=0 && this->gptr()<=this->pptr() )
  454.         this->setg(this->eback(),this->gptr(),this->pptr());
  455.       else
  456.       {
  457.         if ( (basic_streambuf<charT,traits>::mode_ & ios_base::out  ) &&
  458.              !(basic_streambuf<charT,traits>::mode_ & ios_base::in ) )
  459.           this->setg(this->pbase(),this->pptr(),this->epptr());
  460.       }
  461.       return pos_type(newoff);
  462.     }
  463.     else 
  464.       if ( basic_streambuf<charT,traits>::mode_ & ios_base::app )
  465.         return pos_type(this->pptr()-this->pbase());
  466.     return pos_type(off_type(-1));
  467.   }
  468.  
  469.   /*
  470.    * streamsize xsputn(const char_type *, streamsize)
  471.    */
  472.  
  473.   template<class charT, class traits, class Allocator>
  474.   streamsize basic_stringbuf<charT, traits, Allocator>::
  475.   xsputn(const char_type *s, streamsize n)
  476.   {
  477.     if ( !s || (n == 0) ) return 0;
  478.  
  479.     if ( n > ( this->epptr()-this->pptr()+128 ) )
  480.     {
  481.       if ( setbuf(0, this->pptr()-this->pbase()+n+128)== 0)
  482.       {
  483.         return 0;
  484.       }
  485.  
  486.       traits::copy(this->pptr(), s, n);
  487.       this->pbump(n);
  488.       __end_pos =  (this->pptr() - this->pbase());
  489.     }
  490.     else
  491.     {
  492.       int         i=0;
  493.       while((i < n) && ( !traits::eq_int_type(sputc(*s++),traits::eof())))
  494.         i++;
  495.       return i;
  496.     }
  497.     return n;    
  498.   }
  499.  
  500.   /*
  501.    * class basic_istringstream
  502.    */
  503.  
  504.   /*
  505.    * basic_istringstream(ios_base::openmode)
  506.    */
  507.  
  508.   template<class charT, class traits, class Allocator>
  509.   basic_istringstream<charT, traits, Allocator>::
  510.   basic_istringstream(ios_base::openmode m)
  511.   : basic_istream<charT, traits>( )
  512.   , __sb(m | ios_base::in)
  513.   {
  514.     init(&__sb);
  515.   }
  516.  
  517.   /*
  518.    * basic_istringstream(const basic_string<charT>&, ios_base::openmode)
  519.    */
  520.  
  521.   template<class charT, class traits, class Allocator>
  522.   basic_istringstream<charT, traits, Allocator>::
  523.   basic_istringstream(const string_type& s, ios_base::openmode which)
  524.   : basic_istream<charT, traits>( )
  525.   , __sb(s, which | ios_base::in)
  526.   {
  527.     init(&__sb);
  528.   }
  529.  
  530.   /*
  531.    * virtual ~basic_istringstream()
  532.    */
  533.  
  534.   template<class charT, class traits, class Allocator>
  535.   basic_istringstream<charT, traits, Allocator>::~basic_istringstream()
  536.   {
  537.   }
  538.  
  539.   /*
  540.    * basic_stringbuf *rdbuf() const
  541.    */
  542.  
  543.   template<class charT, class traits, class Allocator>
  544.   basic_stringbuf<charT, traits, Allocator> *
  545.   basic_istringstream<charT, traits, Allocator>::rdbuf() const
  546.   {
  547.     return (basic_stringbuf<charT, traits, Allocator> *)&__sb;
  548.   }
  549.  
  550.   /*
  551.    * basic_string<charT> str() const
  552.    */
  553.  
  554.   template<class charT, class traits, class Allocator>
  555.   basic_string<charT, traits, Allocator>
  556.   basic_istringstream<charT, traits, Allocator>::str() const
  557.   {
  558.     return __sb.str();
  559.   }
  560.  
  561.   /*
  562.    * void str(const basic_string<charT>& )
  563.    */
  564.  
  565.   template<class charT, class traits, class Allocator>
  566.   void basic_istringstream<charT, traits, Allocator>::str(const string_type& s)
  567.   {
  568.     __sb.str(s);
  569.   }
  570.  
  571.   /*
  572.    * class basic_ostringstring
  573.    */
  574.  
  575.   /*
  576.    * basic_ostringstream(ios_base::openmode)
  577.    */
  578.  
  579.   template<class charT, class traits, class Allocator>
  580.   basic_ostringstream<charT, traits, Allocator>::
  581.   basic_ostringstream(ios_base::openmode w)
  582.   : basic_ostream<charT, traits>( )           
  583.   , __sb(w | ios_base::out )
  584.   {
  585.     init(&__sb);
  586.   }
  587.  
  588.   /*
  589.    * basic_ostringstream(const basic_string&, ios_base::openmode)
  590.    */
  591.  
  592.   template<class charT, class traits, class Allocator>
  593.   basic_ostringstream<charT, traits, Allocator>::
  594.   basic_ostringstream(const string_type& s, ios_base::openmode which)
  595.   : basic_ostream<charT, traits>( )
  596.   , __sb(s, which | ios_base::out )
  597.   {
  598.     init(&__sb);
  599.   }
  600.  
  601.   /*
  602.    * virtual ~basic_ostringstream()
  603.    */
  604.  
  605.   template<class charT, class traits, class Allocator>
  606.   basic_ostringstream<charT, traits, Allocator>::~basic_ostringstream()
  607.   {
  608.   }
  609.  
  610.   /*
  611.    * basic_stringbuf *rdbuf() const
  612.    */
  613.  
  614.   template<class charT, class traits, class Allocator>
  615.   basic_stringbuf<charT, traits, Allocator> *
  616.   basic_ostringstream<charT, traits, Allocator>::rdbuf() const
  617.   {
  618.     return (basic_stringbuf<charT, traits, Allocator> *)&__sb;
  619.   }
  620.  
  621.   /*
  622.    * basic_string str() const
  623.    */
  624.  
  625.   template<class charT, class traits, class Allocator>
  626.   basic_string<charT, traits, Allocator>
  627.   basic_ostringstream<charT, traits, Allocator>::str() const
  628.   {
  629.     return __sb.str();
  630.   }
  631.  
  632.   /*
  633.    * void str(const basic_string& s)
  634.    */
  635.  
  636.   template<class charT, class traits, class Allocator>
  637.   void basic_ostringstream<charT, traits, Allocator>::
  638.   str(const string_type& s)
  639.   {
  640.     __sb.str(s);
  641.   }
  642.  
  643.   /*
  644.    * class basic_stringstream
  645.    */
  646.  
  647.   /*
  648.    * basic_stringstream(ios_base::openmode)
  649.    */
  650.  
  651.   template<class charT, class traits, class Allocator>
  652.   basic_stringstream<charT, traits, Allocator>::
  653.   basic_stringstream(ios_base::openmode w)
  654.   : basic_iostream<charT, traits>( )          
  655.   , __sb(w)
  656.   {
  657.     init(&__sb);
  658.   }
  659.  
  660.   /*
  661.    * basic_stringstream(const basic_string&, ios_base::openmode)
  662.    */
  663.  
  664.   template<class charT, class traits, class Allocator>
  665.   basic_stringstream<charT, traits, Allocator>::
  666.   basic_stringstream(const string_type& s, ios_base::openmode which)
  667.   : basic_iostream<charT, traits>( )
  668.   , __sb(s, which)
  669.   {
  670.     init(&__sb);
  671.   }
  672.  
  673.   /*
  674.    * virtual ~basic_stringstream()
  675.    */
  676.  
  677.   template<class charT, class traits, class Allocator>
  678.   basic_stringstream<charT, traits, Allocator>::~basic_stringstream()
  679.   {
  680.   }
  681.  
  682.   /*
  683.    * basic_stringbuf *rdbuf() const
  684.    */
  685.  
  686.   template<class charT, class traits, class Allocator>
  687.   basic_stringbuf<charT, traits, Allocator> *
  688.   basic_stringstream<charT, traits, Allocator>::rdbuf() const
  689.   {
  690.     return (basic_stringbuf<charT, traits, Allocator> *)&__sb;
  691.   }
  692.  
  693.   /*
  694.    * basic_string str() const
  695.    */
  696.  
  697.   template<class charT, class traits, class Allocator>
  698.   basic_string<charT, traits, Allocator>
  699.   basic_stringstream<charT, traits, Allocator>::str() const
  700.   {
  701.     return __sb.str();
  702.   }
  703.  
  704.   /*
  705.    * void str(const basic_string& s)
  706.    */
  707.  
  708.   template<class charT, class traits, class Allocator>
  709.   void basic_stringstream<charT, traits, Allocator>::
  710.   str(const string_type& s)
  711.   {
  712.     __sb.str(s);
  713.   }
  714. #ifndef _RWSTD_NO_NAMESPACE
  715. }
  716. #endif
  717.  
  718. #pragma option pop
  719. #endif /* __SSTREAM_CC */
  720.