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_CHAIN_HPP_INCLUDED |
9 | #define BOOST_IOSTREAMS_DETAIL_CHAIN_HPP_INCLUDED |
10 | |
11 | #if defined(_MSC_VER) |
12 | # pragma once |
13 | #endif |
14 | |
15 | #include <boost/assert.hpp> |
16 | #include <exception> |
17 | #include <iterator> // advance. |
18 | #include <list> |
19 | #include <memory> // allocator, auto_ptr or unique_ptr. |
20 | #include <stdexcept> // logic_error, out_of_range. |
21 | #include <boost/checked_delete.hpp> |
22 | #include <boost/config.hpp> // BOOST_MSVC, template friends, |
23 | #include <boost/detail/workaround.hpp> // BOOST_NESTED_TEMPLATE |
24 | #include <boost/core/typeinfo.hpp> |
25 | #include <boost/iostreams/constants.hpp> |
26 | #include <boost/iostreams/detail/access_control.hpp> |
27 | #include <boost/iostreams/detail/char_traits.hpp> |
28 | #include <boost/iostreams/detail/push.hpp> |
29 | #include <boost/iostreams/detail/streambuf.hpp> // pubsync. |
30 | #include <boost/iostreams/detail/wrap_unwrap.hpp> |
31 | #include <boost/iostreams/device/null.hpp> |
32 | #include <boost/iostreams/positioning.hpp> |
33 | #include <boost/iostreams/traits.hpp> // is_filter. |
34 | #include <boost/iostreams/stream_buffer.hpp> |
35 | #include <boost/next_prior.hpp> |
36 | #include <boost/shared_ptr.hpp> |
37 | #include <boost/static_assert.hpp> |
38 | #include <boost/throw_exception.hpp> |
39 | #include <boost/type_traits/is_convertible.hpp> |
40 | #include <boost/type.hpp> |
41 | #include <boost/iostreams/detail/execute.hpp> |
42 | |
43 | // Sometimes type_info objects must be compared by name. Borrowed from |
44 | // Boost.Python and Boost.Function. |
45 | #if defined(__GNUC__) || \ |
46 | defined(_AIX) || \ |
47 | (defined(__sgi) && defined(__host_mips)) || \ |
48 | (defined(linux) && defined(__INTEL_COMPILER) && defined(__ICC)) \ |
49 | /**/ |
50 | # include <cstring> |
51 | # define BOOST_IOSTREAMS_COMPARE_TYPE_ID(X,Y) \ |
52 | (std::strcmp((X).name(),(Y).name()) == 0) |
53 | #else |
54 | # define BOOST_IOSTREAMS_COMPARE_TYPE_ID(X,Y) ((X)==(Y)) |
55 | #endif |
56 | |
57 | // Deprecated. Unused. |
58 | #define BOOST_IOSTREAMS_COMPONENT_TYPE(chain, index) \ |
59 | chain.component_type( index ) \ |
60 | /**/ |
61 | |
62 | // Deprecated. Unused. |
63 | #define BOOST_IOSTREAMS_COMPONENT(chain, index, target) \ |
64 | chain.component< target >( index ) \ |
65 | /**/ |
66 | |
67 | namespace boost { namespace iostreams { |
68 | |
69 | //--------------Definition of chain and wchain--------------------------------// |
70 | |
71 | namespace detail { |
72 | |
73 | template<typename Chain> class chain_client; |
74 | |
75 | // |
76 | // Concept name: Chain. |
77 | // Description: Represents a chain of stream buffers which provides access |
78 | // to the first buffer in the chain and sends notifications when the |
79 | // streambufs are added to or removed from chain. |
80 | // Refines: Closable device with mode equal to typename Chain::mode. |
81 | // Models: chain, converting_chain. |
82 | // Example: |
83 | // |
84 | // class chain { |
85 | // public: |
86 | // typedef xxx chain_type; |
87 | // typedef xxx client_type; |
88 | // typedef xxx mode; |
89 | // bool is_complete() const; // Ready for i/o. |
90 | // template<typename T> |
91 | // void push( const T& t, // Adds a stream buffer to |
92 | // streamsize, // chain, based on t, with |
93 | // streamsize ); // given buffer and putback |
94 | // // buffer sizes. Pass -1 to |
95 | // // request default size. |
96 | // protected: |
97 | // void register_client(client_type* client); // Associate client. |
98 | // void notify(); // Notify client. |
99 | // }; |
100 | // |
101 | |
102 | // |
103 | // Description: Represents a chain of filters with an optional device at the |
104 | // end. |
105 | // Template parameters: |
106 | // Self - A class deriving from the current instantiation of this template. |
107 | // This is an example of the Curiously Recurring Template Pattern. |
108 | // Ch - The character type. |
109 | // Tr - The character traits type. |
110 | // Alloc - The allocator type. |
111 | // Mode - A mode tag. |
112 | // |
113 | template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode> |
114 | class chain_base { |
115 | public: |
116 | typedef Ch char_type; |
117 | BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr) |
118 | typedef Alloc allocator_type; |
119 | typedef Mode mode; |
120 | struct category |
121 | : Mode, |
122 | device_tag |
123 | { }; |
124 | typedef chain_client<Self> client_type; |
125 | friend class chain_client<Self>; |
126 | private: |
127 | typedef linked_streambuf<Ch> streambuf_type; |
128 | typedef std::list<streambuf_type*> list_type; |
129 | typedef chain_base<Self, Ch, Tr, Alloc, Mode> my_type; |
130 | protected: |
131 | chain_base() : pimpl_(new chain_impl) { } |
132 | chain_base(const chain_base& rhs): pimpl_(rhs.pimpl_) { } |
133 | public: |
134 | |
135 | // dual_use is a pseudo-mode to facilitate filter writing, |
136 | // not a genuine mode. |
137 | BOOST_STATIC_ASSERT((!is_convertible<mode, dual_use>::value)); |
138 | |
139 | //----------Buffer sizing-------------------------------------------------// |
140 | |
141 | // Sets the size of the buffer created for the devices to be added to this |
142 | // chain. Does not affect the size of the buffer for devices already |
143 | // added. |
144 | void set_device_buffer_size(std::streamsize n) |
145 | { pimpl_->device_buffer_size_ = n; } |
146 | |
147 | // Sets the size of the buffer created for the filters to be added |
148 | // to this chain. Does not affect the size of the buffer for filters already |
149 | // added. |
150 | void set_filter_buffer_size(std::streamsize n) |
151 | { pimpl_->filter_buffer_size_ = n; } |
152 | |
153 | // Sets the size of the putback buffer for filters and devices to be added |
154 | // to this chain. Does not affect the size of the buffer for filters or |
155 | // devices already added. |
156 | void set_pback_size(std::streamsize n) |
157 | { pimpl_->pback_size_ = n; } |
158 | |
159 | //----------Device interface----------------------------------------------// |
160 | |
161 | std::streamsize read(char_type* s, std::streamsize n); |
162 | std::streamsize write(const char_type* s, std::streamsize n); |
163 | std::streampos seek(stream_offset off, BOOST_IOS::seekdir way); |
164 | |
165 | //----------Direct component access---------------------------------------// |
166 | |
167 | const boost::core::typeinfo& component_type(int n) const |
168 | { |
169 | if (static_cast<size_type>(n) >= size()) |
170 | boost::throw_exception(e: std::out_of_range("bad chain offset" )); |
171 | return (*boost::next(list().begin(), n))->component_type(); |
172 | } |
173 | |
174 | // Deprecated. |
175 | template<int N> |
176 | const boost::core::typeinfo& component_type() const { return component_type(N); } |
177 | |
178 | template<typename T> |
179 | T* component(int n) const { return component(n, boost::type<T>()); } |
180 | |
181 | // Deprecated. |
182 | template<int N, typename T> |
183 | T* component() const { return component<T>(N); } |
184 | |
185 | #if !BOOST_WORKAROUND(BOOST_MSVC, == 1310) |
186 | private: |
187 | #endif |
188 | template<typename T> |
189 | T* component(int n, boost::type<T>) const |
190 | { |
191 | if (static_cast<size_type>(n) >= size()) |
192 | boost::throw_exception(e: std::out_of_range("bad chain offset" )); |
193 | streambuf_type* link = *boost::next(list().begin(), n); |
194 | if (BOOST_IOSTREAMS_COMPARE_TYPE_ID(link->component_type(), BOOST_CORE_TYPEID(T))) |
195 | return static_cast<T*>(link->component_impl()); |
196 | else |
197 | return 0; |
198 | } |
199 | public: |
200 | |
201 | //----------Container-like interface--------------------------------------// |
202 | |
203 | typedef typename list_type::size_type size_type; |
204 | streambuf_type& front() { return *list().front(); } |
205 | BOOST_IOSTREAMS_DEFINE_PUSH(push, mode, char_type, push_impl) |
206 | void pop(); |
207 | bool empty() const { return list().empty(); } |
208 | size_type size() const { return list().size(); } |
209 | void reset(); |
210 | |
211 | //----------Additional i/o functions--------------------------------------// |
212 | |
213 | // Returns true if this chain is non-empty and its final link |
214 | // is a source or sink, i.e., if it is ready to perform i/o. |
215 | bool is_complete() const; |
216 | bool auto_close() const; |
217 | void set_auto_close(bool close); |
218 | bool sync() { return front().BOOST_IOSTREAMS_PUBSYNC() != -1; } |
219 | bool strict_sync(); |
220 | private: |
221 | template<typename T> |
222 | void push_impl(const T& t, std::streamsize buffer_size = -1, |
223 | std::streamsize pback_size = -1) |
224 | { |
225 | typedef typename iostreams::category_of<T>::type category; |
226 | typedef typename unwrap_ios<T>::type component_type; |
227 | typedef stream_buffer< |
228 | component_type, |
229 | BOOST_IOSTREAMS_CHAR_TRAITS(char_type), |
230 | Alloc, Mode |
231 | > streambuf_t; |
232 | typedef typename list_type::iterator iterator; |
233 | BOOST_STATIC_ASSERT((is_convertible<category, Mode>::value)); |
234 | if (is_complete()) |
235 | boost::throw_exception(e: std::logic_error("chain complete" )); |
236 | streambuf_type* prev = !empty() ? list().back() : 0; |
237 | buffer_size = |
238 | buffer_size != -1 ? |
239 | buffer_size : |
240 | iostreams::optimal_buffer_size(t); |
241 | pback_size = |
242 | pback_size != -1 ? |
243 | pback_size : |
244 | pimpl_->pback_size_; |
245 | |
246 | #if defined(BOOST_NO_CXX11_SMART_PTR) |
247 | |
248 | std::auto_ptr<streambuf_t> |
249 | buf(new streambuf_t(t, buffer_size, pback_size)); |
250 | |
251 | #else |
252 | |
253 | std::unique_ptr<streambuf_t> |
254 | buf(new streambuf_t(t, buffer_size, pback_size)); |
255 | |
256 | #endif |
257 | |
258 | list().push_back(buf.get()); |
259 | buf.release(); |
260 | if (is_device<component_type>::value) { |
261 | pimpl_->flags_ |= f_complete | f_open; |
262 | for ( iterator first = list().begin(), |
263 | last = list().end(); |
264 | first != last; |
265 | ++first ) |
266 | { |
267 | (*first)->set_needs_close(); |
268 | } |
269 | } |
270 | if (prev) prev->set_next(list().back()); |
271 | notify(); |
272 | } |
273 | |
274 | list_type& list() { return pimpl_->links_; } |
275 | const list_type& list() const { return pimpl_->links_; } |
276 | void register_client(client_type* client) { pimpl_->client_ = client; } |
277 | void notify() { if (pimpl_->client_) pimpl_->client_->notify(); } |
278 | |
279 | //----------Nested classes------------------------------------------------// |
280 | |
281 | static void close(streambuf_type* b, BOOST_IOS::openmode m) |
282 | { |
283 | if (m == BOOST_IOS::out && is_convertible<Mode, output>::value) |
284 | b->BOOST_IOSTREAMS_PUBSYNC(); |
285 | b->close(m); |
286 | } |
287 | |
288 | static void set_next(streambuf_type* b, streambuf_type* next) |
289 | { b->set_next(next); } |
290 | |
291 | static void set_auto_close(streambuf_type* b, bool close) |
292 | { b->set_auto_close(close); } |
293 | |
294 | struct closer { |
295 | typedef streambuf_type* argument_type; |
296 | typedef void result_type; |
297 | closer(BOOST_IOS::openmode m) : mode_(m) { } |
298 | void operator() (streambuf_type* b) |
299 | { |
300 | close(b, m: mode_); |
301 | } |
302 | BOOST_IOS::openmode mode_; |
303 | }; |
304 | friend struct closer; |
305 | |
306 | enum flags { |
307 | f_complete = 1, |
308 | f_open = 2, |
309 | f_auto_close = 4 |
310 | }; |
311 | |
312 | struct chain_impl { |
313 | chain_impl() |
314 | : client_(0), device_buffer_size_(default_device_buffer_size), |
315 | filter_buffer_size_(default_filter_buffer_size), |
316 | pback_size_(default_pback_buffer_size), |
317 | flags_(f_auto_close) |
318 | { } |
319 | ~chain_impl() |
320 | { |
321 | try { close(); } catch (...) { } |
322 | try { reset(); } catch (...) { } |
323 | } |
324 | void close() |
325 | { |
326 | if ((flags_ & f_open) != 0) { |
327 | flags_ &= ~f_open; |
328 | stream_buffer< basic_null_device<Ch, Mode> > null; |
329 | if ((flags_ & f_complete) == 0) { |
330 | null.open(basic_null_device<Ch, Mode>()); |
331 | set_next(b: links_.back(), next: &null); |
332 | } |
333 | links_.front()->BOOST_IOSTREAMS_PUBSYNC(); |
334 | try { |
335 | boost::iostreams::detail::execute_foreach( |
336 | links_.rbegin(), links_.rend(), |
337 | closer(BOOST_IOS::in) |
338 | ); |
339 | } catch (...) { |
340 | try { |
341 | boost::iostreams::detail::execute_foreach( |
342 | links_.begin(), links_.end(), |
343 | closer(BOOST_IOS::out) |
344 | ); |
345 | } catch (...) { } |
346 | throw; |
347 | } |
348 | boost::iostreams::detail::execute_foreach( |
349 | links_.begin(), links_.end(), |
350 | closer(BOOST_IOS::out) |
351 | ); |
352 | } |
353 | } |
354 | void reset() |
355 | { |
356 | typedef typename list_type::iterator iterator; |
357 | for ( iterator first = links_.begin(), |
358 | last = links_.end(); |
359 | first != last; |
360 | ++first ) |
361 | { |
362 | if ( (flags_ & f_complete) == 0 || |
363 | (flags_ & f_auto_close) == 0 ) |
364 | { |
365 | set_auto_close(*first, false); |
366 | } |
367 | streambuf_type* buf = 0; |
368 | std::swap(buf, *first); |
369 | delete buf; |
370 | } |
371 | links_.clear(); |
372 | flags_ &= ~f_complete; |
373 | flags_ &= ~f_open; |
374 | } |
375 | list_type links_; |
376 | client_type* client_; |
377 | std::streamsize device_buffer_size_, |
378 | filter_buffer_size_, |
379 | pback_size_; |
380 | int flags_; |
381 | }; |
382 | friend struct chain_impl; |
383 | |
384 | //----------Member data---------------------------------------------------// |
385 | |
386 | private: |
387 | shared_ptr<chain_impl> pimpl_; |
388 | }; |
389 | |
390 | } // End namespace detail. |
391 | |
392 | // |
393 | // Macro: BOOST_IOSTREAMS_DECL_CHAIN(name, category) |
394 | // Description: Defines a template derived from chain_base appropriate for a |
395 | // particular i/o category. The template has the following parameters: |
396 | // Ch - The character type. |
397 | // Tr - The character traits type. |
398 | // Alloc - The allocator type. |
399 | // Macro parameters: |
400 | // name_ - The name of the template to be defined. |
401 | // category_ - The i/o category of the template to be defined. |
402 | // |
403 | #define BOOST_IOSTREAMS_DECL_CHAIN(name_, default_char_) \ |
404 | template< typename Mode, typename Ch = default_char_, \ |
405 | typename Tr = BOOST_IOSTREAMS_CHAR_TRAITS(Ch), \ |
406 | typename Alloc = std::allocator<Ch> > \ |
407 | class name_ : public boost::iostreams::detail::chain_base< \ |
408 | name_<Mode, Ch, Tr, Alloc>, \ |
409 | Ch, Tr, Alloc, Mode \ |
410 | > \ |
411 | { \ |
412 | public: \ |
413 | struct category : device_tag, Mode { }; \ |
414 | typedef Mode mode; \ |
415 | private: \ |
416 | typedef boost::iostreams::detail::chain_base< \ |
417 | name_<Mode, Ch, Tr, Alloc>, \ |
418 | Ch, Tr, Alloc, Mode \ |
419 | > base_type; \ |
420 | public: \ |
421 | typedef Ch char_type; \ |
422 | typedef Tr traits_type; \ |
423 | typedef typename traits_type::int_type int_type; \ |
424 | typedef typename traits_type::off_type off_type; \ |
425 | name_() { } \ |
426 | name_(const name_& rhs) : base_type(rhs) { } \ |
427 | name_& operator=(const name_& rhs) \ |
428 | { base_type::operator=(rhs); return *this; } \ |
429 | }; \ |
430 | /**/ |
431 | BOOST_IOSTREAMS_DECL_CHAIN(chain, char) |
432 | BOOST_IOSTREAMS_DECL_CHAIN(wchain, wchar_t) |
433 | #undef BOOST_IOSTREAMS_DECL_CHAIN |
434 | |
435 | //--------------Definition of chain_client------------------------------------// |
436 | |
437 | namespace detail { |
438 | |
439 | // |
440 | // Template name: chain_client |
441 | // Description: Class whose instances provide access to an underlying chain |
442 | // using an interface similar to the chains. |
443 | // Subclasses: the various stream and stream buffer templates. |
444 | // |
445 | template<typename Chain> |
446 | class chain_client { |
447 | public: |
448 | typedef Chain chain_type; |
449 | typedef typename chain_type::char_type char_type; |
450 | typedef typename chain_type::traits_type traits_type; |
451 | typedef typename chain_type::size_type size_type; |
452 | typedef typename chain_type::mode mode; |
453 | |
454 | chain_client(chain_type* chn = 0) : chain_(chn ) { } |
455 | chain_client(chain_client* client) : chain_(client->chain_) { } |
456 | virtual ~chain_client() { } |
457 | |
458 | const boost::core::typeinfo& component_type(int n) const |
459 | { return chain_->component_type(n); } |
460 | |
461 | // Deprecated. |
462 | template<int N> |
463 | const boost::core::typeinfo& component_type() const |
464 | { return chain_->BOOST_NESTED_TEMPLATE component_type<N>(); } |
465 | |
466 | template<typename T> |
467 | T* component(int n) const |
468 | { return chain_->BOOST_NESTED_TEMPLATE component<T>(n); } |
469 | |
470 | // Deprecated. |
471 | template<int N, typename T> |
472 | T* component() const |
473 | { return chain_->BOOST_NESTED_TEMPLATE component<N, T>(); } |
474 | |
475 | bool is_complete() const { return chain_->is_complete(); } |
476 | bool auto_close() const { return chain_->auto_close(); } |
477 | void set_auto_close(bool close) { chain_->set_auto_close(close); } |
478 | bool strict_sync() { return chain_->strict_sync(); } |
479 | void set_device_buffer_size(std::streamsize n) |
480 | { chain_->set_device_buffer_size(n); } |
481 | void set_filter_buffer_size(std::streamsize n) |
482 | { chain_->set_filter_buffer_size(n); } |
483 | void set_pback_size(std::streamsize n) { chain_->set_pback_size(n); } |
484 | BOOST_IOSTREAMS_DEFINE_PUSH(push, mode, char_type, push_impl) |
485 | void pop() { chain_->pop(); } |
486 | bool empty() const { return chain_->empty(); } |
487 | size_type size() const { return chain_->size(); } |
488 | void reset() { chain_->reset(); } |
489 | |
490 | // Returns a copy of the underlying chain. |
491 | chain_type filters() { return *chain_; } |
492 | chain_type filters() const { return *chain_; } |
493 | protected: |
494 | template<typename T> |
495 | void push_impl(const T& t BOOST_IOSTREAMS_PUSH_PARAMS()) |
496 | { chain_->push(t BOOST_IOSTREAMS_PUSH_ARGS()); } |
497 | chain_type& ref() { return *chain_; } |
498 | void set_chain(chain_type* c) |
499 | { chain_ = c; chain_->register_client(this); } |
500 | #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && \ |
501 | (!BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600)) |
502 | template<typename S, typename C, typename T, typename A, typename M> |
503 | friend class chain_base; |
504 | #else |
505 | public: |
506 | #endif |
507 | virtual void notify() { } |
508 | private: |
509 | chain_type* chain_; |
510 | }; |
511 | |
512 | //--------------Implementation of chain_base----------------------------------// |
513 | |
514 | template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode> |
515 | inline std::streamsize chain_base<Self, Ch, Tr, Alloc, Mode>::read |
516 | (char_type* s, std::streamsize n) |
517 | { return iostreams::read(*list().front(), s, n); } |
518 | |
519 | template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode> |
520 | inline std::streamsize chain_base<Self, Ch, Tr, Alloc, Mode>::write |
521 | (const char_type* s, std::streamsize n) |
522 | { return iostreams::write(*list().front(), s, n); } |
523 | |
524 | template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode> |
525 | inline std::streampos chain_base<Self, Ch, Tr, Alloc, Mode>::seek |
526 | (stream_offset off, BOOST_IOS::seekdir way) |
527 | { return iostreams::seek(*list().front(), off, way); } |
528 | |
529 | template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode> |
530 | void chain_base<Self, Ch, Tr, Alloc, Mode>::reset() |
531 | { |
532 | using namespace std; |
533 | pimpl_->close(); |
534 | pimpl_->reset(); |
535 | } |
536 | |
537 | template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode> |
538 | bool chain_base<Self, Ch, Tr, Alloc, Mode>::is_complete() const |
539 | { |
540 | return (pimpl_->flags_ & f_complete) != 0; |
541 | } |
542 | |
543 | template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode> |
544 | bool chain_base<Self, Ch, Tr, Alloc, Mode>::auto_close() const |
545 | { |
546 | return (pimpl_->flags_ & f_auto_close) != 0; |
547 | } |
548 | |
549 | template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode> |
550 | void chain_base<Self, Ch, Tr, Alloc, Mode>::set_auto_close(bool close) |
551 | { |
552 | pimpl_->flags_ = |
553 | (pimpl_->flags_ & ~f_auto_close) | |
554 | (close ? f_auto_close : 0); |
555 | } |
556 | |
557 | template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode> |
558 | bool chain_base<Self, Ch, Tr, Alloc, Mode>::strict_sync() |
559 | { |
560 | typedef typename list_type::iterator iterator; |
561 | bool result = true; |
562 | for ( iterator first = list().begin(), |
563 | last = list().end(); |
564 | first != last; |
565 | ++first ) |
566 | { |
567 | bool s = (*first)->strict_sync(); |
568 | result = result && s; |
569 | } |
570 | return result; |
571 | } |
572 | |
573 | template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode> |
574 | void chain_base<Self, Ch, Tr, Alloc, Mode>::pop() |
575 | { |
576 | BOOST_ASSERT(!empty()); |
577 | if (auto_close()) |
578 | pimpl_->close(); |
579 | streambuf_type* buf = 0; |
580 | std::swap(buf, list().back()); |
581 | buf->set_auto_close(false); |
582 | buf->set_next(0); |
583 | delete buf; |
584 | list().pop_back(); |
585 | pimpl_->flags_ &= ~f_complete; |
586 | if (auto_close() || list().empty()) |
587 | pimpl_->flags_ &= ~f_open; |
588 | } |
589 | |
590 | } // End namespace detail. |
591 | |
592 | } } // End namespaces iostreams, boost. |
593 | |
594 | #endif // #ifndef BOOST_IOSTREAMS_DETAIL_CHAIN_HPP_INCLUDED |
595 | |