|
|
// ---------------------------------------------------------------------------- |
|
|
// 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); // <EFBFBD>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; |
|
|
#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 |
|
|
|
|
|
|
