PageRenderTime 65ms CodeModel.GetById 16ms app.highlight 44ms RepoModel.GetById 1ms app.codeStats 1ms

/src/contrib/boost/format/alt_sstream.hpp

http://pythonocc.googlecode.com/
C++ Header | 176 lines | 134 code | 28 blank | 14 comment | 0 complexity | 4677f27fd2628fe4eac8fb8e8c8cbd64 MD5 | raw file
  1// ----------------------------------------------------------------------------
  2//  alt_sstream.hpp : alternative stringstream 
  3// ----------------------------------------------------------------------------
  4
  5//  Copyright Samuel Krempp 2003. Use, modification, and distribution are
  6//  subject to the Boost Software License, Version 1.0. (See accompanying
  7//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  8
  9//  See http://www.boost.org/libs/format for library home page
 10
 11// ----------------------------------------------------------------------------
 12
 13
 14
 15#ifndef BOOST_SK_ALT_SSTREAM_HPP
 16#define BOOST_SK_ALT_SSTREAM_HPP
 17
 18#include <string>
 19#include <boost/format/detail/compat_workarounds.hpp>
 20#include <boost/utility/base_from_member.hpp>
 21#include <boost/shared_ptr.hpp>
 22#include <boost/assert.hpp>
 23
 24namespace boost {
 25    namespace io {
 26
 27        template<class Ch, class Tr=::std::char_traits<Ch>, 
 28                 class Alloc=::std::allocator<Ch> >
 29        class basic_altstringbuf;
 30
 31        template<class Ch, class Tr =::std::char_traits<Ch>, 
 32                 class Alloc=::std::allocator<Ch> >
 33        class basic_oaltstringstream;
 34
 35
 36        template<class Ch, class Tr, class Alloc>
 37        class basic_altstringbuf 
 38            : public ::std::basic_streambuf<Ch, Tr>
 39        {
 40            typedef ::std::basic_streambuf<Ch, Tr>  streambuf_t;
 41            typedef typename CompatAlloc<Alloc>::compatible_type compat_allocator_type;
 42            typedef typename CompatTraits<Tr>::compatible_type   compat_traits_type;
 43        public:
 44            typedef Ch     char_type;
 45            typedef Tr     traits_type;
 46            typedef typename compat_traits_type::int_type     int_type;
 47            typedef typename compat_traits_type::pos_type     pos_type;
 48            typedef typename compat_traits_type::off_type     off_type;
 49            typedef Alloc                     allocator_type;
 50            typedef ::std::basic_string<Ch, Tr, Alloc> string_type;
 51            typedef typename string_type::size_type    size_type;
 52
 53            typedef ::std::streamsize streamsize;
 54
 55
 56            explicit basic_altstringbuf(std::ios_base::openmode mode
 57                                        = std::ios_base::in | std::ios_base::out)
 58                : putend_(NULL), is_allocated_(false), mode_(mode) 
 59                {}
 60            explicit basic_altstringbuf(const string_type& s,
 61                                        ::std::ios_base::openmode mode
 62                                        = ::std::ios_base::in | ::std::ios_base::out)
 63                : putend_(NULL), is_allocated_(false), mode_(mode) 
 64                { dealloc(); str(s); }
 65            virtual ~basic_altstringbuf() 
 66                { dealloc(); }
 67            using streambuf_t::pbase;
 68            using streambuf_t::pptr;
 69            using streambuf_t::epptr;
 70            using streambuf_t::eback;
 71            using streambuf_t::gptr;
 72            using streambuf_t::egptr;
 73    
 74            void clear_buffer();
 75            void str(const string_type& s);
 76
 77            // 0-copy access :
 78            Ch * begin() const; 
 79            size_type size() const;
 80            size_type cur_size() const; // stop at current pointer
 81            Ch * pend() const // the highest position reached by pptr() since creation
 82                { return ((putend_ < pptr()) ? pptr() : putend_); }
 83            size_type pcount() const 
 84                { return static_cast<size_type>( pptr() - pbase()) ;}
 85
 86            // copy buffer to string :
 87            string_type str() const 
 88                { return string_type(begin(), size()); }
 89            string_type cur_str() const 
 90                { return string_type(begin(), cur_size()); }
 91        protected:
 92            explicit basic_altstringbuf (basic_altstringbuf * s,
 93                                         ::std::ios_base::openmode mode 
 94                                         = ::std::ios_base::in | ::std::ios_base::out)
 95                : putend_(NULL), is_allocated_(false), mode_(mode) 
 96                { dealloc(); str(s); }
 97
 98            virtual pos_type seekoff(off_type off, ::std::ios_base::seekdir way, 
 99                                     ::std::ios_base::openmode which 
100                                     = ::std::ios_base::in | ::std::ios_base::out);
101            virtual pos_type seekpos (pos_type pos, 
102                                      ::std::ios_base::openmode which 
103                                      = ::std::ios_base::in | ::std::ios_base::out);
104            virtual int_type underflow();
105            virtual int_type pbackfail(int_type meta = compat_traits_type::eof());
106            virtual int_type overflow(int_type meta = compat_traits_type::eof());
107            void dealloc();
108        private:
109            enum { alloc_min = 256}; // minimum size of allocations
110
111            Ch *putend_;  // remembers (over seeks) the highest value of pptr()
112            bool is_allocated_;
113            ::std::ios_base::openmode mode_;
114            compat_allocator_type alloc_;  // the allocator object
115        };
116
117
118// ---   class basic_oaltstringstream ----------------------------------------
119        template <class Ch, class Tr, class Alloc>
120        class basic_oaltstringstream 
121            : private base_from_member< shared_ptr< basic_altstringbuf< Ch, Tr, Alloc> > >,
122              public ::std::basic_ostream<Ch, Tr>
123        {
124            class No_Op { 
125                // used as no-op deleter for (not-owner) shared_pointers
126            public: 
127                template<class T>
128                const T & operator()(const T & arg) { return arg; }
129            };
130            typedef ::std::basic_ostream<Ch, Tr> stream_t;
131            typedef boost::base_from_member<boost::shared_ptr<
132                basic_altstringbuf<Ch,Tr, Alloc> > > 
133                pbase_type;
134            typedef ::std::basic_string<Ch, Tr, Alloc>  string_type;
135            typedef typename string_type::size_type     size_type;
136            typedef basic_altstringbuf<Ch, Tr, Alloc>   stringbuf_t;
137        public:
138            typedef Alloc  allocator_type;
139            basic_oaltstringstream() 
140                : pbase_type(new stringbuf_t), stream_t(rdbuf()) 
141                { }
142            basic_oaltstringstream(::boost::shared_ptr<stringbuf_t> buf) 
143                : pbase_type(buf), stream_t(rdbuf()) 
144                { }
145            basic_oaltstringstream(stringbuf_t * buf) 
146                : pbase_type(buf, No_Op() ), stream_t(rdbuf()) 
147                { }
148            stringbuf_t * rdbuf() const 
149                { return pbase_type::member.get(); }
150            void clear_buffer() 
151                { rdbuf()->clear_buffer(); }
152
153            // 0-copy access :
154            Ch * begin() const 
155                { return rdbuf()->begin(); }
156            size_type size() const 
157                { return rdbuf()->size(); }
158            size_type cur_size() const // stops at current position
159                { return rdbuf()->cur_size(); }
160
161            // copy buffer to string :
162            string_type str()     const   // [pbase, epptr[
163                { return rdbuf()->str(); } 
164            string_type cur_str() const   // [pbase, pptr[
165                { return rdbuf()->cur_str(); }
166            void str(const string_type& s) 
167                { rdbuf()->str(s); }
168        };
169
170    } // N.S. io
171} // N.S. boost
172
173#include <boost/format/alt_sstream_impl.hpp>
174
175#endif // include guard
176