text: ﻿// ----------------------------------------------------------------------------
  //  alt_sstream_impl.hpp : alternative stringstream, templates implementation 
  // ----------------------------------------------------------------------------
  
  //  Copyright Samuel Krempp 2003. Use, modification, and distribution are
  //  subject to the Boost Software License, Version 1.0. (See accompanying
  //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  
  //  See http://www.boost.org/libs/format for library home page
  
  // ----------------------------------------------------------------------------
  
  #ifndef BOOST_SK_ALT_SSTREAM_IMPL_HPP
  #define BOOST_SK_ALT_SSTREAM_IMPL_HPP
  
  namespace boost {
      namespace io {
  // --- Implementation  ------------------------------------------------------//
  
          template<class Ch, class Tr, class Alloc>
          void basic_altstringbuf<Ch, Tr, Alloc>:: 
          clear_buffer () {
              const Ch * p = pptr();
              const Ch * b = pbase();
              if(p != NULL && p != b) {
                  seekpos(0, ::std::ios_base::out); 
              }
              p = gptr();
              b = eback();
              if(p != NULL && p != b) {
                  seekpos(0, ::std::ios_base::in); 
              }
          }
  
          template<class Ch, class Tr, class Alloc>
          void basic_altstringbuf<Ch, Tr, Alloc>:: 
          str (const string_type& s) {
              size_type sz=s.size();
              if(sz != 0 && mode_ & (::std::ios_base::in | ::std::ios_base::out) ) {
  #ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
                  void *vd_ptr = alloc_.allocate(sz, is_allocated_? eback() : 0);
                  Ch *new_ptr = static_cast<Ch *>(vd_ptr);
  #else
                  Ch *new_ptr = alloc_.allocate(sz, is_allocated_? eback() : 0);
  #endif
                  // if this didnt throw, we're safe, update the buffer
                  dealloc();
                  sz = s.copy(new_ptr, sz);
                  putend_ = new_ptr + sz;
                  if(mode_ & ::std::ios_base::in)
                      streambuf_t::setg(new_ptr, new_ptr, new_ptr + sz);
                  if(mode_ & ::std::ios_base::out) {
                      streambuf_t::setp(new_ptr, new_ptr + sz);
                      if(mode_ & (::std::ios_base::app | ::std::ios_base::ate))
                          streambuf_t::pbump(static_cast<int>(sz));
                      if(gptr() == NULL)
                          streambuf_t::setg(new_ptr, NULL, new_ptr);
                  }
                  is_allocated_ = true;
              }
              else 
                  dealloc();
          }
          template<class Ch, class Tr, class Alloc>
          Ch*   basic_altstringbuf<Ch, Tr, Alloc>:: 
          begin () const {
              if(mode_ & ::std::ios_base::out && pptr() != NULL)
                  return pbase();
              else if(mode_ & ::std::ios_base::in && gptr() != NULL)
                  return eback();
              return NULL;
          }
  
          template<class Ch, class Tr, class Alloc>
          typename std::basic_string<Ch,Tr,Alloc>::size_type
          basic_altstringbuf<Ch, Tr, Alloc>:: 
          size () const { 
              if(mode_ & ::std::ios_base::out && pptr())
                  return static_cast<size_type>(pend() - pbase());
              else if(mode_ & ::std::ios_base::in && gptr())
                  return static_cast<size_type>(egptr() - eback());
              else 
                  return 0;
          }
  
          template<class Ch, class Tr, class Alloc>
          typename std::basic_string<Ch,Tr,Alloc>::size_type
          basic_altstringbuf<Ch, Tr, Alloc>:: 
          cur_size () const { 
              if(mode_ & ::std::ios_base::out && pptr())
                  return static_cast<streamsize>( pptr() - pbase());
              else if(mode_ & ::std::ios_base::in && gptr())
                  return static_cast<streamsize>( gptr() - eback());
              else 
                  return 0;
          }
  
          template<class Ch, class Tr, class Alloc>
          typename basic_altstringbuf<Ch, Tr, Alloc>::pos_type  
          basic_altstringbuf<Ch, Tr, Alloc>:: 
          seekoff (off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) {
              if(pptr() != NULL && putend_ < pptr())
                  putend_ = pptr();
              if(which & ::std::ios_base::in && gptr() != NULL) {
                  // get area
                  if(way == ::std::ios_base::end)
                      off += static_cast<off_type>(putend_ - gptr());
                  else if(way == ::std::ios_base::beg)
                      off += static_cast<off_type>(eback() - gptr());
                  else if(way != ::std::ios_base::cur || (which & ::std::ios_base::out) )
                      // (altering in&out is only supported if way is beg or end, not cur)
                      return pos_type(off_type(-1));
                  if(eback() <= off+gptr() && off+gptr() <= putend_ ) {
                      // set gptr
                      streambuf_t::gbump(static_cast<int>(off));
                      if(which & ::std::ios_base::out && pptr() != NULL)
                          // update pptr to match gptr
                          streambuf_t::pbump(static_cast<int>(gptr()-pptr()));
                  }
                  else
                      off = off_type(-1);
              }
              else if(which & ::std::ios_base::out && pptr() != NULL) {
                  // put area
                  if(way == ::std::ios_base::end)
                      off += static_cast<off_type>(putend_ - pptr());
                  else if(way == ::std::ios_base::beg)
                      off += static_cast<off_type>(pbase() - pptr());
                  else if(way != ::std::ios_base::beg)
                      return pos_type(off_type(-1));                    
                  if(pbase() <= off+pptr() && off+pptr() <= putend_)
                      // set pptr
                      streambuf_t::pbump(static_cast<int>(off)); 
                  else
                      off = off_type(-1);
              }
              else // neither in nor out
                  off = off_type(-1);
              return (pos_type(off));
          }
          //- end seekoff(..)
  
          
          template<class Ch, class Tr, class Alloc>
          typename basic_altstringbuf<Ch, Tr, Alloc>::pos_type 
          basic_altstringbuf<Ch, Tr, Alloc>:: 
          seekpos (pos_type pos, ::std::ios_base::openmode which) {
              off_type off = off_type(pos); // operation guaranteed by 27.4.3.2 table 88
              if(pptr() != NULL && putend_ < pptr())
                  putend_ = pptr();
              if(off != off_type(-1)) {
                  if(which & ::std::ios_base::in && gptr() != NULL) {
                      // get area
                      if(0 <= off && off <= putend_ - eback()) {
                          streambuf_t::gbump(static_cast<int>(eback() - gptr() + off));
                          if(which & ::std::ios_base::out && pptr() != NULL) {
                              // update pptr to match gptr
                              streambuf_t::pbump(static_cast<int>(gptr()-pptr()));
                          }
                      }
                      else
                          off = off_type(-1);
                  }
                  else if(which & ::std::ios_base::out && pptr() != NULL) {
                      // put area
                      if(0 <= off && off <= putend_ - eback())
                          streambuf_t::pbump(static_cast<int>(eback() - pptr() + off));
                      else
                          off = off_type(-1);
                  }
                  else // neither in nor out
                      off = off_type(-1);
                  return (pos_type(off));
              }
              else {
                  BOOST_ASSERT(0); // ?7.4.3.2 allows undefined-behaviour here
                  return pos_type(off_type(-1));
              }
          }
          // -end seekpos(..)
  
  
          template<class Ch, class Tr, class Alloc>
          typename basic_altstringbuf<Ch, Tr, Alloc>::int_type
          basic_altstringbuf<Ch, Tr, Alloc>:: 
          underflow () {
              if(gptr() == NULL) // no get area -> nothing to get.
                  return (compat_traits_type::eof()); 
              else if(gptr() < egptr())  // ok, in buffer
                  return (compat_traits_type::to_int_type(*gptr())); 
              else if(mode_ & ::std::ios_base::in && pptr() != NULL
                      && (gptr() < pptr() || gptr() < putend_) )
                  {  // expand get area 
                      if(putend_ < pptr()) 
                          putend_ = pptr(); // remember pptr reached this far
                      streambuf_t::setg(eback(), gptr(), putend_);
                      return (compat_traits_type::to_int_type(*gptr()));
                  }
              else // couldnt get anything. EOF.
                  return (compat_traits_type::eof());
          }
          // -end underflow(..)
  
  
          template<class Ch, class Tr, class Alloc>
          typename basic_altstringbuf<Ch, Tr, Alloc>::int_type 
          basic_altstringbuf<Ch, Tr, Alloc>:: 
          pbackfail (int_type meta) {
              if(gptr() != NULL  &&  (eback() < gptr()) 
                 && (mode_ & (::std::ios_base::out)
                     || compat_traits_type::eq_int_type(compat_traits_type::eof(), meta)
                     || compat_traits_type::eq(compat_traits_type::to_char_type(meta), gptr()[-1]) ) ) { 
                  streambuf_t::gbump(-1); // back one character
                  if(!compat_traits_type::eq_int_type(compat_traits_type::eof(), meta))
                      //  put-back meta into get area
                      *gptr() = compat_traits_type::to_char_type(meta);
                  return (compat_traits_type::not_eof(meta));
              }
              else
                  return (compat_traits_type::eof());  // failed putback
          }
          // -end pbackfail(..)
  
  
          template<class Ch, class Tr, class Alloc>
          typename basic_altstringbuf<Ch, Tr, Alloc>::int_type 
          basic_altstringbuf<Ch, Tr, Alloc>:: 
          overflow (int_type meta) {
  #ifdef BOOST_MSVC
  #pragma warning(push)
  #pragma warning(disable:4996)
  #endif
              if(compat_traits_type::eq_int_type(compat_traits_type::eof(), meta))
                  return compat_traits_type::not_eof(meta); // nothing to do
              else if(pptr() != NULL && pptr() < epptr()) {
                  streambuf_t::sputc(compat_traits_type::to_char_type(meta));
                  return meta;
              }
              else if(! (mode_ & ::std::ios_base::out)) 
                  // no write position, and cant make one
                  return compat_traits_type::eof(); 
              else { // make a write position available
                  std::size_t prev_size = pptr() == NULL ? 0 : epptr() - eback();
                  std::size_t new_size = prev_size;
                  // exponential growth : size *= 1.5
                  std::size_t add_size = new_size / 2;
                  if(add_size < alloc_min)
                      add_size = alloc_min;
                  Ch * newptr = NULL,  *oldptr = eback();
  
                  // make sure adding add_size wont overflow size_t
                  while (0 < add_size && ((std::numeric_limits<std::size_t>::max)()
                                          - add_size < new_size) )
                      add_size /= 2;
                  if(0 < add_size) {
                      new_size += add_size;
  #ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
                      void *vdptr = alloc_.allocate(new_size, is_allocated_? oldptr : 0);
                      newptr = static_cast<Ch *>(vdptr);
  #else
                      newptr = alloc_.allocate(new_size, is_allocated_? oldptr : 0);
  #endif
                  }
  
                  if(0 < prev_size)
                      compat_traits_type::copy(newptr, oldptr, prev_size);
                  if(is_allocated_)
                      alloc_.deallocate(oldptr, prev_size);
                  is_allocated_=true;
  
                  if(prev_size == 0) { // first allocation
                      putend_ = newptr;
                      streambuf_t::setp(newptr, newptr + new_size);
                      if(mode_ & ::std::ios_base::in)
                          streambuf_t::setg(newptr, newptr, newptr + 1);
                      else
                          streambuf_t::setg(newptr, 0, newptr);
                  }
                  else { // update pointers
                      putend_ = putend_ - oldptr + newptr;
                      int pptr_count = static_cast<int>(pptr()-pbase());
                      int gptr_count = static_cast<int>(gptr()-eback());
                      streambuf_t::setp(pbase() - oldptr + newptr, newptr + new_size);
                      streambuf_t::pbump(pptr_count);
                      if(mode_ & ::std::ios_base::in)
                          streambuf_t::setg(newptr, newptr + gptr_count, pptr() + 1);
                      else
                          streambuf_t::setg(newptr, 0, newptr);
                  }
                  streambuf_t::sputc(compat_traits_type::to_char_type(meta));
                  return meta;
              }
  #ifdef BOOST_MSVC
  #pragma warning(pop)
  #endif
          }
          // -end overflow(..)
  
          template<class Ch, class Tr, class Alloc>
          void basic_altstringbuf<Ch, Tr, Alloc>:: dealloc() {
              if(is_allocated_)
                  alloc_.deallocate(eback(), (pptr() != NULL ? epptr() : egptr()) - eback());
              is_allocated_ = false;
              streambuf_t::setg(0, 0, 0);
              streambuf_t::setp(0, 0);
              putend_ = NULL;
          }
  
      }// N.S. io
  } // N.S. boost
  
  #endif // include guard
  
  