boost/format/alt_sstream_impl.hpp
// ---------------------------------------------------------------------------- // 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) ) { Ch *new_ptr = alloc_.allocate(sz, is_allocated_? eback() : 0); // 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); // �27.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; newptr = alloc_.allocate(new_size, is_allocated_? oldptr : 0); } 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