1// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
2// (C) Copyright 2003-2007 Jonathan Turkanis
3// Distributed under the Boost Software License, Version 1.0. (See accompanying
4// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.)
5
6// See http://www.boost.org/libs/iostreams for documentation.
7
8#ifndef BOOST_IOSTREAMS_DETAIL_DIRECT_STREAMBUF_HPP_INCLUDED
9#define BOOST_IOSTREAMS_DETAIL_DIRECT_STREAMBUF_HPP_INCLUDED
10
11#if defined(_MSC_VER)
12# pragma once
13#endif
14
15#include <boost/assert.hpp>
16#include <cstddef>
17#include <utility> // pair.
18#include <boost/config.hpp> // BOOST_DEDUCED_TYPENAME,
19#include <boost/core/typeinfo.hpp>
20#include <boost/iostreams/detail/char_traits.hpp> // member template friends.
21#include <boost/iostreams/detail/config/wide_streams.hpp>
22#include <boost/iostreams/detail/error.hpp>
23#include <boost/iostreams/detail/execute.hpp>
24#include <boost/iostreams/detail/functional.hpp>
25#include <boost/iostreams/detail/ios.hpp>
26#include <boost/iostreams/detail/optional.hpp>
27#include <boost/iostreams/detail/streambuf.hpp>
28#include <boost/iostreams/detail/streambuf/linked_streambuf.hpp>
29#include <boost/iostreams/operations.hpp>
30#include <boost/iostreams/positioning.hpp>
31#include <boost/iostreams/traits.hpp>
32#include <boost/throw_exception.hpp>
33
34// Must come last.
35#include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC.
36
37namespace boost { namespace iostreams {
38
39namespace detail {
40
41template< typename T,
42 typename Tr =
43 BOOST_IOSTREAMS_CHAR_TRAITS(
44 BOOST_DEDUCED_TYPENAME char_type_of<T>::type
45 ) >
46class direct_streambuf
47 : public linked_streambuf<BOOST_DEDUCED_TYPENAME char_type_of<T>::type, Tr>
48{
49public:
50 typedef typename char_type_of<T>::type char_type;
51 BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)
52private:
53 typedef linked_streambuf<char_type, traits_type> base_type;
54 typedef typename category_of<T>::type category;
55 typedef BOOST_IOSTREAMS_BASIC_STREAMBUF(
56 char_type, traits_type
57 ) streambuf_type;
58public: // stream needs access.
59 void open(const T& t, std::streamsize buffer_size,
60 std::streamsize pback_size);
61 bool is_open() const;
62 void close();
63 bool auto_close() const { return auto_close_; }
64 void set_auto_close(bool close) { auto_close_ = close; }
65 bool strict_sync() { return true; }
66
67 // Declared in linked_streambuf.
68 T* component() { return storage_.get(); }
69protected:
70 BOOST_IOSTREAMS_USING_PROTECTED_STREAMBUF_MEMBERS(base_type)
71 direct_streambuf();
72
73 //--------------Virtual functions-----------------------------------------//
74
75 // Declared in linked_streambuf.
76 void close_impl(BOOST_IOS::openmode m);
77 const boost::core::typeinfo& component_type() const { return BOOST_CORE_TYPEID(T); }
78 void* component_impl() { return component(); }
79#ifdef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES
80 public:
81#endif
82
83 // Declared in basic_streambuf.
84 int_type underflow();
85 int_type pbackfail(int_type c);
86 int_type overflow(int_type c);
87 pos_type seekoff( off_type off, BOOST_IOS::seekdir way,
88 BOOST_IOS::openmode which );
89 pos_type seekpos(pos_type sp, BOOST_IOS::openmode which);
90private:
91 pos_type seek_impl( stream_offset off, BOOST_IOS::seekdir way,
92 BOOST_IOS::openmode which );
93 void init_input(any_tag) { }
94 void init_input(input);
95 void init_output(any_tag) { }
96 void init_output(output);
97 void init_get_area();
98 void init_put_area();
99 bool one_head() const;
100 bool two_head() const;
101 optional<T> storage_;
102 char_type *ibeg_, *iend_, *obeg_, *oend_;
103 bool auto_close_;
104};
105
106//------------------Implementation of direct_streambuf------------------------//
107
108template<typename T, typename Tr>
109direct_streambuf<T, Tr>::direct_streambuf()
110 : ibeg_(0), iend_(0), obeg_(0), oend_(0), auto_close_(true)
111{ this->set_true_eof(true); }
112
113template<typename T, typename Tr>
114void direct_streambuf<T, Tr>::open
115 (const T& t, std::streamsize, std::streamsize)
116{
117 storage_.reset(t);
118 init_input(category());
119 init_output(category());
120 setg(0, 0, 0);
121 setp(0, 0);
122 this->set_needs_close();
123}
124
125template<typename T, typename Tr>
126bool direct_streambuf<T, Tr>::is_open() const
127{ return ibeg_ != 0 || obeg_ != 0; }
128
129template<typename T, typename Tr>
130void direct_streambuf<T, Tr>::close()
131{
132 base_type* self = this;
133 detail::execute_all( detail::call_member_close(*self, BOOST_IOS::in),
134 detail::call_member_close(*self, BOOST_IOS::out),
135 detail::call_reset(storage_) );
136}
137
138template<typename T, typename Tr>
139typename direct_streambuf<T, Tr>::int_type
140direct_streambuf<T, Tr>::underflow()
141{
142 if (!ibeg_)
143 boost::throw_exception(e: cant_read());
144 if (!gptr())
145 init_get_area();
146 return gptr() != iend_ ?
147 traits_type::to_int_type(*gptr()) :
148 traits_type::eof();
149}
150
151template<typename T, typename Tr>
152typename direct_streambuf<T, Tr>::int_type
153direct_streambuf<T, Tr>::pbackfail(int_type c)
154{
155 using namespace std;
156 if (!ibeg_)
157 boost::throw_exception(e: cant_read());
158 if (gptr() != 0 && gptr() != ibeg_) {
159 gbump(-1);
160 if (!traits_type::eq_int_type(c, traits_type::eof()))
161 *gptr() = traits_type::to_char_type(c);
162 return traits_type::not_eof(c);
163 }
164 boost::throw_exception(e: bad_putback());
165}
166
167template<typename T, typename Tr>
168typename direct_streambuf<T, Tr>::int_type
169direct_streambuf<T, Tr>::overflow(int_type c)
170{
171 using namespace std;
172 if (!obeg_)
173 boost::throw_exception(BOOST_IOSTREAMS_FAILURE("no write access"));
174 if (!pptr()) init_put_area();
175 if (!traits_type::eq_int_type(c, traits_type::eof())) {
176 if (pptr() == oend_)
177 boost::throw_exception(
178 BOOST_IOSTREAMS_FAILURE("write area exhausted")
179 );
180 *pptr() = traits_type::to_char_type(c);
181 pbump(1);
182 return c;
183 }
184 return traits_type::not_eof(c);
185}
186
187template<typename T, typename Tr>
188inline typename direct_streambuf<T, Tr>::pos_type
189direct_streambuf<T, Tr>::seekoff
190 (off_type off, BOOST_IOS::seekdir way, BOOST_IOS::openmode which)
191{ return seek_impl(off, way, which); }
192
193template<typename T, typename Tr>
194inline typename direct_streambuf<T, Tr>::pos_type
195direct_streambuf<T, Tr>::seekpos
196 (pos_type sp, BOOST_IOS::openmode which)
197{
198 return seek_impl(off: position_to_offset(sp), BOOST_IOS::beg, which);
199}
200
201template<typename T, typename Tr>
202void direct_streambuf<T, Tr>::close_impl(BOOST_IOS::openmode which)
203{
204 if (which == BOOST_IOS::in && ibeg_ != 0) {
205 setg(0, 0, 0);
206 ibeg_ = iend_ = 0;
207 }
208 if (which == BOOST_IOS::out && obeg_ != 0) {
209 sync();
210 setp(0, 0);
211 obeg_ = oend_ = 0;
212 }
213 boost::iostreams::close(*storage_, which);
214}
215
216template<typename T, typename Tr>
217typename direct_streambuf<T, Tr>::pos_type direct_streambuf<T, Tr>::seek_impl
218 (stream_offset off, BOOST_IOS::seekdir way, BOOST_IOS::openmode which)
219{
220 using namespace std;
221 BOOST_IOS::openmode both = BOOST_IOS::in | BOOST_IOS::out;
222 if (two_head() && (which & both) == both)
223 boost::throw_exception(e: bad_seek());
224 stream_offset result = -1;
225 bool one = one_head();
226 if (one && (pptr() != 0 || gptr()== 0))
227 init_get_area(); // Switch to input mode, for code reuse.
228 if (one || ((which & BOOST_IOS::in) != 0 && ibeg_ != 0)) {
229 if (!gptr()) setg(ibeg_, ibeg_, iend_);
230 ptrdiff_t next = 0;
231 switch (way) {
232 case BOOST_IOS::beg: next = off; break;
233 case BOOST_IOS::cur: next = (gptr() - ibeg_) + off; break;
234 case BOOST_IOS::end: next = (iend_ - ibeg_) + off; break;
235 default: BOOST_ASSERT(0);
236 }
237 if (next < 0 || next > (iend_ - ibeg_))
238 boost::throw_exception(e: bad_seek());
239 setg(ibeg_, ibeg_ + next, iend_);
240 result = next;
241 }
242 if (!one && (which & BOOST_IOS::out) != 0 && obeg_ != 0) {
243 if (!pptr()) setp(obeg_, oend_);
244 ptrdiff_t next = 0;
245 switch (way) {
246 case BOOST_IOS::beg: next = off; break;
247 case BOOST_IOS::cur: next = (pptr() - obeg_) + off; break;
248 case BOOST_IOS::end: next = (oend_ - obeg_) + off; break;
249 default: BOOST_ASSERT(0);
250 }
251 if (next < 0 || next > (oend_ - obeg_))
252 boost::throw_exception(e: bad_seek());
253 pbump(static_cast<int>(next - (pptr() - obeg_)));
254 result = next;
255 }
256 return offset_to_position(off: result);
257}
258
259template<typename T, typename Tr>
260void direct_streambuf<T, Tr>::init_input(input)
261{
262 std::pair<char_type*, char_type*> p = input_sequence(*storage_);
263 ibeg_ = p.first;
264 iend_ = p.second;
265}
266
267template<typename T, typename Tr>
268void direct_streambuf<T, Tr>::init_output(output)
269{
270 std::pair<char_type*, char_type*> p = output_sequence(*storage_);
271 obeg_ = p.first;
272 oend_ = p.second;
273}
274
275template<typename T, typename Tr>
276void direct_streambuf<T, Tr>::init_get_area()
277{
278 setg(ibeg_, ibeg_, iend_);
279 if (one_head() && pptr()) {
280 gbump(static_cast<int>(pptr() - obeg_));
281 setp(0, 0);
282 }
283}
284
285template<typename T, typename Tr>
286void direct_streambuf<T, Tr>::init_put_area()
287{
288 setp(obeg_, oend_);
289 if (one_head() && gptr()) {
290 pbump(static_cast<int>(gptr() - ibeg_));
291 setg(0, 0, 0);
292 }
293}
294
295template<typename T, typename Tr>
296inline bool direct_streambuf<T, Tr>::one_head() const
297{ return ibeg_ && obeg_ && ibeg_ == obeg_; }
298
299template<typename T, typename Tr>
300inline bool direct_streambuf<T, Tr>::two_head() const
301{ return ibeg_ && obeg_ && ibeg_ != obeg_; }
302
303//----------------------------------------------------------------------------//
304
305} // End namespace detail.
306
307} } // End namespaces iostreams, boost.
308
309#include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC
310
311#endif // #ifndef BOOST_IOSTREAMS_DETAIL_DIRECT_STREAMBUF_HPP_INCLUDED
312

source code of boost/libs/iostreams/include/boost/iostreams/detail/streambuf/direct_streambuf.hpp