You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
176 lines
7.3 KiB
176 lines
7.3 KiB
// ---------------------------------------------------------------------------- |
|
// alt_sstream.hpp : alternative stringstream |
|
// ---------------------------------------------------------------------------- |
|
|
|
// 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_HPP |
|
#define BOOST_SK_ALT_SSTREAM_HPP |
|
|
|
#include <string> |
|
#include <boost/format/detail/compat_workarounds.hpp> |
|
#include <boost/utility/base_from_member.hpp> |
|
#include <boost/shared_ptr.hpp> |
|
#include <boost/assert.hpp> |
|
|
|
namespace boost { |
|
namespace io { |
|
|
|
template<class Ch, class Tr=::std::char_traits<Ch>, |
|
class Alloc=::std::allocator<Ch> > |
|
class basic_altstringbuf; |
|
|
|
template<class Ch, class Tr =::std::char_traits<Ch>, |
|
class Alloc=::std::allocator<Ch> > |
|
class basic_oaltstringstream; |
|
|
|
|
|
template<class Ch, class Tr, class Alloc> |
|
class basic_altstringbuf |
|
: public ::std::basic_streambuf<Ch, Tr> |
|
{ |
|
typedef ::std::basic_streambuf<Ch, Tr> streambuf_t; |
|
typedef typename CompatAlloc<Alloc>::compatible_type compat_allocator_type; |
|
typedef typename CompatTraits<Tr>::compatible_type compat_traits_type; |
|
public: |
|
typedef Ch char_type; |
|
typedef Tr traits_type; |
|
typedef typename compat_traits_type::int_type int_type; |
|
typedef typename compat_traits_type::pos_type pos_type; |
|
typedef typename compat_traits_type::off_type off_type; |
|
typedef Alloc allocator_type; |
|
typedef ::std::basic_string<Ch, Tr, Alloc> string_type; |
|
typedef typename string_type::size_type size_type; |
|
|
|
typedef ::std::streamsize streamsize; |
|
|
|
|
|
explicit basic_altstringbuf(std::ios_base::openmode mode |
|
= std::ios_base::in | std::ios_base::out) |
|
: putend_(NULL), is_allocated_(false), mode_(mode) |
|
{} |
|
explicit basic_altstringbuf(const string_type& s, |
|
::std::ios_base::openmode mode |
|
= ::std::ios_base::in | ::std::ios_base::out) |
|
: putend_(NULL), is_allocated_(false), mode_(mode) |
|
{ dealloc(); str(s); } |
|
virtual ~basic_altstringbuf() |
|
{ dealloc(); } |
|
using streambuf_t::pbase; |
|
using streambuf_t::pptr; |
|
using streambuf_t::epptr; |
|
using streambuf_t::eback; |
|
using streambuf_t::gptr; |
|
using streambuf_t::egptr; |
|
|
|
void clear_buffer(); |
|
void str(const string_type& s); |
|
|
|
// 0-copy access : |
|
Ch * begin() const; |
|
size_type size() const; |
|
size_type cur_size() const; // stop at current pointer |
|
Ch * pend() const // the highest position reached by pptr() since creation |
|
{ return ((putend_ < pptr()) ? pptr() : putend_); } |
|
size_type pcount() const |
|
{ return static_cast<size_type>( pptr() - pbase()) ;} |
|
|
|
// copy buffer to string : |
|
string_type str() const |
|
{ return string_type(begin(), size()); } |
|
string_type cur_str() const |
|
{ return string_type(begin(), cur_size()); } |
|
protected: |
|
explicit basic_altstringbuf (basic_altstringbuf * s, |
|
::std::ios_base::openmode mode |
|
= ::std::ios_base::in | ::std::ios_base::out) |
|
: putend_(NULL), is_allocated_(false), mode_(mode) |
|
{ dealloc(); str(s); } |
|
|
|
virtual pos_type seekoff(off_type off, ::std::ios_base::seekdir way, |
|
::std::ios_base::openmode which |
|
= ::std::ios_base::in | ::std::ios_base::out); |
|
virtual pos_type seekpos (pos_type pos, |
|
::std::ios_base::openmode which |
|
= ::std::ios_base::in | ::std::ios_base::out); |
|
virtual int_type underflow(); |
|
virtual int_type pbackfail(int_type meta = compat_traits_type::eof()); |
|
virtual int_type overflow(int_type meta = compat_traits_type::eof()); |
|
void dealloc(); |
|
private: |
|
enum { alloc_min = 256}; // minimum size of allocations |
|
|
|
Ch *putend_; // remembers (over seeks) the highest value of pptr() |
|
bool is_allocated_; |
|
::std::ios_base::openmode mode_; |
|
compat_allocator_type alloc_; // the allocator object |
|
}; |
|
|
|
|
|
// --- class basic_oaltstringstream ---------------------------------------- |
|
template <class Ch, class Tr, class Alloc> |
|
class basic_oaltstringstream |
|
: private base_from_member< shared_ptr< basic_altstringbuf< Ch, Tr, Alloc> > >, |
|
public ::std::basic_ostream<Ch, Tr> |
|
{ |
|
class No_Op { |
|
// used as no-op deleter for (not-owner) shared_pointers |
|
public: |
|
template<class T> |
|
const T & operator()(const T & arg) { return arg; } |
|
}; |
|
typedef ::std::basic_ostream<Ch, Tr> stream_t; |
|
typedef boost::base_from_member<boost::shared_ptr< |
|
basic_altstringbuf<Ch,Tr, Alloc> > > |
|
pbase_type; |
|
typedef ::std::basic_string<Ch, Tr, Alloc> string_type; |
|
typedef typename string_type::size_type size_type; |
|
typedef basic_altstringbuf<Ch, Tr, Alloc> stringbuf_t; |
|
public: |
|
typedef Alloc allocator_type; |
|
basic_oaltstringstream() |
|
: pbase_type(new stringbuf_t), stream_t(rdbuf()) |
|
{ } |
|
basic_oaltstringstream(::boost::shared_ptr<stringbuf_t> buf) |
|
: pbase_type(buf), stream_t(rdbuf()) |
|
{ } |
|
basic_oaltstringstream(stringbuf_t * buf) |
|
: pbase_type(buf, No_Op() ), stream_t(rdbuf()) |
|
{ } |
|
stringbuf_t * rdbuf() const |
|
{ return pbase_type::member.get(); } |
|
void clear_buffer() |
|
{ rdbuf()->clear_buffer(); } |
|
|
|
// 0-copy access : |
|
Ch * begin() const |
|
{ return rdbuf()->begin(); } |
|
size_type size() const |
|
{ return rdbuf()->size(); } |
|
size_type cur_size() const // stops at current position |
|
{ return rdbuf()->cur_size(); } |
|
|
|
// copy buffer to string : |
|
string_type str() const // [pbase, epptr[ |
|
{ return rdbuf()->str(); } |
|
string_type cur_str() const // [pbase, pptr[ |
|
{ return rdbuf()->cur_str(); } |
|
void str(const string_type& s) |
|
{ rdbuf()->str(s); } |
|
}; |
|
|
|
} // N.S. io |
|
} // N.S. boost |
|
|
|
#include <boost/format/alt_sstream_impl.hpp> |
|
|
|
#endif // include guard |
|
|
|
|