1 // (C) Copyright Jonathan Turkanis 2003.

     2 // Distributed under the Boost Software License, Version 1.0. (See accompanying

     3 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.)

     4 

     5 // See http://www.boost.org/libs/iostreams for documentation.

     6 

     7 #ifndef BOOST_IOSTREAMS_DETAIL_CHAIN_HPP_INCLUDED

     8 #define BOOST_IOSTREAMS_DETAIL_CHAIN_HPP_INCLUDED

     9 

    10 #if defined(_MSC_VER) && (_MSC_VER >= 1020)

    11 # pragma once

    12 #endif

    13 

    14 #include <algorithm>                            // for_each.

    15 #include <cassert>

    16 #include <exception>

    17 #include <functional>                           // unary_function.

    18 #include <iterator>                             // advance.

    19 #include <list>

    20 #include <memory>                               // allocator, auto_ptr.

    21 #include <typeinfo>

    22 #include <stdexcept>                            // logic_error, out_of_range.

    23 #include <boost/checked_delete.hpp>

    24 #include <boost/config.hpp>                     // BOOST_MSVC, template friends,

    25 #include <boost/detail/workaround.hpp>          // BOOST_NESTED_TEMPLATE 

    26 #include <boost/iostreams/constants.hpp>

    27 #include <boost/iostreams/detail/access_control.hpp>

    28 #include <boost/iostreams/detail/char_traits.hpp>

    29 #include <boost/iostreams/detail/push.hpp>

    30 #include <boost/iostreams/detail/streambuf.hpp> // pubsync.

    31 #include <boost/iostreams/detail/wrap_unwrap.hpp>

    32 #include <boost/iostreams/device/null.hpp>

    33 #include <boost/iostreams/positioning.hpp>

    34 #include <boost/iostreams/traits.hpp>           // is_filter.

    35 #include <boost/iostreams/stream_buffer.hpp>

    36 #include <boost/next_prior.hpp>

    37 #include <boost/shared_ptr.hpp>

    38 #include <boost/static_assert.hpp>

    39 #include <boost/type_traits/is_convertible.hpp>

    40 #include <boost/type.hpp>

    41 #if BOOST_WORKAROUND(BOOST_MSVC, < 1310)

    42 # include <boost/mpl/int.hpp>

    43 #endif

    44 

    45 // Sometimes type_info objects must be compared by name. Borrowed from

    46 // Boost.Python and Boost.Function.

    47 #if (defined(__GNUC__) && __GNUC__ >= 3) || \

    48      defined(_AIX) || \

    49     (defined(__sgi) && defined(__host_mips)) || \

    50     (defined(linux) && defined(__INTEL_COMPILER) && defined(__ICC)) \

    51     /**/

    52 # include <cstring>

    53 # define BOOST_IOSTREAMS_COMPARE_TYPE_ID(X,Y) \

    54      (std::strcmp((X).name(),(Y).name()) == 0)

    55 #else

    56 # define BOOST_IOSTREAMS_COMPARE_TYPE_ID(X,Y) ((X)==(Y))

    57 #endif

    58 

    59 // Deprecated

    60 #define BOOST_IOSTREAMS_COMPONENT_TYPE(chain, index) \

    61     chain.component_type( index ) \

    62     /**/

    63 

    64 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)

    65 # define BOOST_IOSTREAMS_COMPONENT(chain, index, target) \

    66     chain.component< target >( index ) \

    67     /**/

    68 #else

    69 # define BOOST_IOSTREAMS_COMPONENT(chain, index, target) \

    70     chain.component( index, ::boost::type< target >() ) \

    71     /**/

    72 #endif

    73 

    74 namespace boost { namespace iostreams {

    75 

    76 //--------------Definition of chain and wchain--------------------------------//

    77 

    78 namespace detail {

    79 

    80 template<typename Chain> class chain_client;

    81 

    82 //

    83 // Concept name: Chain.

    84 // Description: Represents a chain of stream buffers which provides access

    85 //     to the first buffer in the chain and send notifications when the

    86 //     streambufs are added to or removed from chain.

    87 // Refines: Closable device with mode equal to typename Chain::mode.

    88 // Models: chain, converting_chain.

    89 // Example:

    90 //

    91 //    class chain {

    92 //    public:

    93 //        typedef xxx chain_type;

    94 //        typedef xxx client_type;

    95 //        typedef xxx mode;

    96 //        bool is_complete() const;                  // Ready for i/o.

    97 //        template<typename T>

    98 //        void push( const T& t,                     // Adds a stream buffer to

    99 //                   streamsize,                     // chain, based on t, with

   100 //                   streamsize );                   // given buffer and putback

   101 //                                                   // buffer sizes. Pass -1 to

   102 //                                                   // request default size.

   103 //    protected:

   104 //        void register_client(client_type* client); // Associate client.

   105 //        void notify();                             // Notify client.

   106 //    };

   107 //

   108 

   109 //

   110 // Description: Represents a chain of filters with an optional device at the

   111 //      end.

   112 // Template parameters:

   113 //      Self - A class deriving from the current instantiation of this template.

   114 //          This is an example of the Curiously Recurring Template Pattern.

   115 //      Ch - The character type.

   116 //      Tr - The character traits type.

   117 //      Alloc - The allocator type.

   118 //      Mode - A mode tag.

   119 //

   120 template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>

   121 class chain_base {

   122 public:

   123     typedef Ch                                     char_type;

   124     BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)

   125     typedef Alloc                                  allocator_type;

   126     typedef Mode                                   mode;

   127     struct category

   128         : Mode,

   129           device_tag

   130         { };

   131     typedef chain_client<Self>                     client_type;

   132     friend class chain_client<Self>;

   133 private:

   134     typedef linked_streambuf<Ch>                   streambuf_type;

   135     typedef std::list<streambuf_type*>             list_type;

   136     typedef chain_base<Self, Ch, Tr, Alloc, Mode>  my_type;

   137 protected:

   138     chain_base() : pimpl_(new chain_impl) { }

   139     chain_base(const chain_base& rhs): pimpl_(rhs.pimpl_) { }

   140 public:

   141 

   142     //----------Buffer sizing-------------------------------------------------//

   143 

   144     // Sets the size of the buffer created for the devices to be added to this

   145     // chain. Does not affect the size of the buffer for devices already

   146     // added.

   147     void set_device_buffer_size(int n) { pimpl_->device_buffer_size_ = n; }

   148 

   149     // Sets the size of the buffer created for the filters to be added

   150     // to this chain. Does not affect the size of the buffer for filters already

   151     // added.

   152     void set_filter_buffer_size(int n) { pimpl_->filter_buffer_size_ = n; }

   153 

   154     // Sets the size of the putback buffer for filters and devices to be added

   155     // to this chain. Does not affect the size of the buffer for filters or

   156     // devices already added.

   157     void set_pback_size(int n) { 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 std::type_info& component_type(int n) const

   168     {

   169         if (static_cast<size_type>(n) >= size())

   170             throw std::out_of_range("bad chain offset");

   171         return (*boost::next(list().begin(), n))->component_type();

   172     }

   173 

   174 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)

   175     // Deprecated.

   176     template<int N>

   177     const std::type_info& component_type() const { return component_type(N); }

   178 

   179     template<typename T>

   180     T* component(int n) const { return component(n, boost::type<T>()); }

   181 

   182     // Deprecated.

   183     template<int N, typename T> 

   184     T* component() const { return component<T>(N); }

   185 #endif

   186 

   187 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)

   188     private:

   189 #endif

   190     template<typename T>

   191     T* component(int n, boost::type<T>) const

   192     {

   193         if (static_cast<size_type>(n) >= size())

   194             throw std::out_of_range("bad chain offset");

   195         streambuf_type* link = *boost::next(list().begin(), n);

   196         if (BOOST_IOSTREAMS_COMPARE_TYPE_ID(link->component_type(), typeid(T)))

   197             return static_cast<T*>(link->component_impl());

   198         else

   199             return 0;

   200     }

   201 public:

   202 

   203     //----------Container-like interface--------------------------------------//

   204 

   205     typedef typename list_type::size_type size_type;

   206     streambuf_type& front() { return *list().front(); }

   207     BOOST_IOSTREAMS_DEFINE_PUSH(push, mode, char_type, push_impl)

   208     void pop();

   209     bool empty() const { return list().empty(); }

   210     size_type size() const { return list().size(); }

   211     void reset();

   212 

   213     //----------Additional i/o functions--------------------------------------//

   214 

   215     // Returns true if this chain is non-empty and its final link

   216     // is a source or sink, i.e., if it is ready to perform i/o.

   217     bool is_complete() const;

   218     bool auto_close() const;

   219     void set_auto_close(bool close);

   220     bool sync() { return front().BOOST_IOSTREAMS_PUBSYNC() != -1; }

   221     bool strict_sync();

   222 private:

   223     template<typename T>

   224     void push_impl(const T& t, int buffer_size = -1, int pback_size = -1)

   225     {

   226         typedef typename iostreams::category_of<T>::type  category;

   227         typedef typename unwrap_ios<T>::type              policy_type;

   228         typedef stream_buffer<

   229                     policy_type,

   230                     BOOST_IOSTREAMS_CHAR_TRAITS(char_type),

   231                     Alloc, Mode

   232                 >                                         facade_type;

   233         BOOST_STATIC_ASSERT((is_convertible<category, Mode>::value));

   234         if (is_complete())

   235             throw 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         std::auto_ptr<facade_type>

   246             buf(new facade_type(t, buffer_size, pback_size));

   247         list().push_back(buf.get());

   248         buf.release();

   249         if (is_device<policy_type>::value)

   250             pimpl_->flags_ |= f_complete | f_open;

   251         if (prev) prev->set_next(list().back());

   252         notify();

   253     }

   254 

   255     list_type& list() { return pimpl_->links_; }

   256     const list_type& list() const { return pimpl_->links_; }

   257     void register_client(client_type* client) { pimpl_->client_ = client; }

   258     void notify() { if (pimpl_->client_) pimpl_->client_->notify(); }

   259 

   260     //----------Nested classes------------------------------------------------//

   261 

   262     static void close(streambuf_type* b, BOOST_IOS::openmode m)

   263     {

   264         if (m & BOOST_IOS::out)

   265             b->BOOST_IOSTREAMS_PUBSYNC();

   266         b->close(m);

   267     }

   268 

   269     static void set_next(streambuf_type* b, streambuf_type* next)

   270     { b->set_next(next); }

   271 

   272     static void set_auto_close(streambuf_type* b, bool close)

   273     { b->set_auto_close(close); }

   274 

   275     struct closer  : public std::unary_function<streambuf_type*, void>  {

   276         closer(BOOST_IOS::openmode m) : mode_(m) { }

   277         void operator() (streambuf_type* b)

   278         {

   279             close(b, mode_);

   280         }

   281         BOOST_IOS::openmode mode_;

   282     };

   283     friend struct closer;

   284 

   285     enum flags {

   286         f_complete = 1,

   287         f_open = 2,

   288         f_auto_close = 4

   289     };

   290 

   291     struct chain_impl {

   292         chain_impl()

   293             : client_(0), device_buffer_size_(default_device_buffer_size),

   294               filter_buffer_size_(default_filter_buffer_size),

   295               pback_size_(default_pback_buffer_size),

   296               flags_(f_auto_close)

   297             { }

   298         ~chain_impl() { try { close(); reset(); } catch (std::exception&) { } }

   299         void close()

   300             {

   301                 if ((flags_ & f_open) != 0) {

   302                     stream_buffer< basic_null_device<Ch, Mode> > null;

   303                     if ((flags_ & f_complete) == 0) {

   304                         null.open(basic_null_device<Ch, Mode>());

   305                         set_next(links_.back(), &null);

   306                     }

   307                     links_.front()->BOOST_IOSTREAMS_PUBSYNC();

   308                     if (is_convertible<Mode, input>::value)

   309                         std::for_each( links_.rbegin(), links_.rend(),

   310                                        closer(BOOST_IOS::in) );

   311                     if (is_convertible<Mode, output>::value)

   312                         std::for_each( links_.begin(), links_.end(),

   313                                        closer(BOOST_IOS::out) );

   314                     flags_ &= ~f_open;

   315                 }

   316             }

   317         void reset()

   318             {

   319                 typedef typename list_type::iterator iterator;

   320                 for ( iterator first = links_.begin(),

   321                                last = links_.end();

   322                       first != last;

   323                       ++first )

   324                 {

   325                     if ( (flags_ & f_complete) == 0 ||

   326                          (flags_ & f_auto_close) == 0 )

   327                     {

   328                         set_auto_close(*first, false);

   329                     }

   330                     streambuf_type* buf = 0;

   331                     std::swap(buf, *first);

   332                     delete buf;

   333                 }

   334                 links_.clear();

   335                 flags_ &= ~f_complete;

   336                 flags_ &= ~f_open;

   337             }

   338         list_type     links_;

   339         client_type*  client_;

   340         int           device_buffer_size_,

   341                       filter_buffer_size_,

   342                       pback_size_;

   343         int           flags_;

   344     };

   345     friend struct chain_impl;

   346 

   347     //----------Member data---------------------------------------------------//

   348 

   349 private:

   350     shared_ptr<chain_impl> pimpl_;

   351 };

   352 

   353 } // End namespace detail.

   354 

   355 //

   356 // Macro: BOOST_IOSTREAMS_DECL_CHAIN(name, category)

   357 // Description: Defines a template derived from chain_base appropriate for a

   358 //      particular i/o category. The template has the following parameters:

   359 //      Ch - The character type.

   360 //      Tr - The character traits type.

   361 //      Alloc - The allocator type.

   362 // Macro parameters:

   363 //      name_ - The name of the template to be defined.

   364 //      category_ - The i/o category of the template to be defined.

   365 //

   366 #define BOOST_IOSTREAMS_DECL_CHAIN(name_, default_char_) \

   367     template< typename Mode, typename Ch = default_char_, \

   368               typename Tr = BOOST_IOSTREAMS_CHAR_TRAITS(Ch), \

   369               typename Alloc = std::allocator<Ch> > \

   370     class name_ : public boost::iostreams::detail::chain_base< \

   371                             name_<Mode, Ch, Tr, Alloc>, \

   372                             Ch, Tr, Alloc, Mode \

   373                          > \

   374     { \

   375     public: \

   376         struct category : device_tag, Mode { }; \

   377         typedef Mode                                   mode; \

   378     private: \

   379         typedef boost::iostreams::detail::chain_base< \

   380                     name_<Mode, Ch, Tr, Alloc>, \

   381                     Ch, Tr, Alloc, Mode \

   382                 >                                      base_type; \

   383     public: \

   384         typedef Ch                                     char_type; \

   385         typedef Tr                                     traits_type; \

   386         typedef typename traits_type::int_type         int_type; \

   387         typedef typename traits_type::off_type         off_type; \

   388         name_() { } \

   389         name_(const name_& rhs) { *this = rhs; } \

   390         name_& operator=(const name_& rhs) \

   391         { base_type::operator=(rhs); return *this; } \

   392     }; \

   393     /**/

   394 BOOST_IOSTREAMS_DECL_CHAIN(chain, char)

   395 BOOST_IOSTREAMS_DECL_CHAIN(wchain, wchar_t)

   396 #undef BOOST_IOSTREAMS_DECL_CHAIN

   397 

   398 //--------------Definition of chain_client------------------------------------//

   399 

   400 namespace detail {

   401 

   402 //

   403 // Template name: chain_client

   404 // Description: Class whose instances provide access to an underlying chain

   405 //      using an interface similar to the chains.

   406 // Subclasses: the various stream and stream buffer templates.

   407 //

   408 template<typename Chain>

   409 class chain_client {

   410 public:

   411     typedef Chain                             chain_type;

   412     typedef typename chain_type::char_type    char_type;

   413     typedef typename chain_type::traits_type  traits_type;

   414     typedef typename chain_type::size_type    size_type;

   415     typedef typename chain_type::mode         mode;

   416 

   417     chain_client(chain_type* chn = 0) : chain_(chn ) { }

   418     chain_client(chain_client* client) : chain_(client->chain_) { }

   419     virtual ~chain_client() { }

   420 

   421     const std::type_info& component_type(int n) const

   422     { return chain_->component_type(n); }

   423 

   424 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)

   425     // Deprecated.

   426     template<int N>

   427     const std::type_info& component_type() const

   428     { return chain_->BOOST_NESTED_TEMPLATE component_type<N>(); }

   429 

   430     template<typename T>

   431     T* component(int n) const

   432     { return chain_->BOOST_NESTED_TEMPLATE component<T>(n); }

   433 

   434     // Deprecated.

   435     template<int N, typename T>

   436     T* component() const

   437     { return chain_->BOOST_NESTED_TEMPLATE component<N, T>(); }

   438 #else

   439     template<typename T>

   440     T* component(int n, boost::type<T> t) const

   441     { return chain_->component(n, t); }

   442 #endif

   443 

   444     bool is_complete() const { return chain_->is_complete(); }

   445     bool auto_close() const { return chain_->auto_close(); }

   446     void set_auto_close(bool close) { chain_->set_auto_close(close); }

   447     bool strict_sync() { return chain_->strict_sync(); }

   448     void set_device_buffer_size(std::streamsize n)

   449         { chain_->set_device_buffer_size(n); }

   450     void set_filter_buffer_size(std::streamsize n)

   451         { chain_->set_filter_buffer_size(n); }

   452     void set_pback_size(std::streamsize n) { chain_->set_pback_size(n); }

   453     BOOST_IOSTREAMS_DEFINE_PUSH(push, mode, char_type, push_impl)

   454     void pop() { chain_->pop(); }

   455     bool empty() const { return chain_->empty(); }

   456     size_type size() { return chain_->size(); }

   457     void reset() { chain_->reset(); }

   458 

   459     // Returns a copy of the underlying chain.

   460     chain_type filters() { return *chain_; }

   461     chain_type filters() const { return *chain_; }

   462 protected:

   463     template<typename T>

   464     void push_impl(const T& t BOOST_IOSTREAMS_PUSH_PARAMS())

   465     { chain_->push(t BOOST_IOSTREAMS_PUSH_ARGS()); }

   466     chain_type& ref() { return *chain_; }

   467     void set_chain(chain_type* c)

   468     { chain_ = c; chain_->register_client(this); }

   469 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) && \

   470     (!BOOST_WORKAROUND(__BORLANDC__, < 0x600))

   471     template<typename S, typename C, typename T, typename A, typename M>

   472     friend class chain_base;

   473 #else

   474     public:

   475 #endif

   476     virtual void notify() { }

   477 private:

   478     chain_type* chain_;

   479 };

   480 

   481 //--------------Implementation of chain_base----------------------------------//

   482 

   483 template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>

   484 inline std::streamsize chain_base<Self, Ch, Tr, Alloc, Mode>::read

   485     (char_type* s, std::streamsize n)

   486 { return iostreams::read(*list().front(), s, n); }

   487 

   488 template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>

   489 inline std::streamsize chain_base<Self, Ch, Tr, Alloc, Mode>::write

   490     (const char_type* s, std::streamsize n)

   491 { return iostreams::write(*list().front(), s, n); }

   492 

   493 template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>

   494 inline std::streampos chain_base<Self, Ch, Tr, Alloc, Mode>::seek

   495     (stream_offset off, BOOST_IOS::seekdir way)

   496 { return iostreams::seek(*list().front(), off, way); }

   497 

   498 template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>

   499 void chain_base<Self, Ch, Tr, Alloc, Mode>::reset()

   500 {

   501     using namespace std;

   502     pimpl_->close();

   503     pimpl_->reset();

   504 }

   505 

   506 template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>

   507 bool chain_base<Self, Ch, Tr, Alloc, Mode>::is_complete() const

   508 {

   509     return (pimpl_->flags_ & f_complete) != 0;

   510 }

   511 

   512 template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>

   513 bool chain_base<Self, Ch, Tr, Alloc, Mode>::auto_close() const

   514 {

   515     return (pimpl_->flags_ & f_auto_close) != 0;

   516 }

   517 

   518 template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>

   519 void chain_base<Self, Ch, Tr, Alloc, Mode>::set_auto_close(bool close)

   520 {

   521     pimpl_->flags_ =

   522         (pimpl_->flags_ & ~f_auto_close) |

   523         (close ? f_auto_close : 0);

   524 }

   525 

   526 template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>

   527 bool chain_base<Self, Ch, Tr, Alloc, Mode>::strict_sync()

   528 {

   529     typedef typename list_type::iterator iterator;

   530     bool result = true;

   531     for ( iterator first = list().begin(),

   532                    last = list().end();

   533           first != last;

   534           ++first )

   535     {

   536         bool s = (*first)->strict_sync();

   537         result = result && s;

   538     }

   539     return result;

   540 }

   541 

   542 template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>

   543 void chain_base<Self, Ch, Tr, Alloc, Mode>::pop()

   544 {

   545     assert(!empty());

   546     if (auto_close())

   547         pimpl_->close();

   548     streambuf_type* buf = 0;

   549     std::swap(buf, list().back());

   550     buf->set_auto_close(false);

   551     buf->set_next(0);

   552     delete buf;

   553     list().pop_back();

   554     pimpl_->flags_ &= ~f_complete;

   555     if (auto_close() || list().empty())

   556         pimpl_->flags_ &= ~f_open;

   557 }

   558 

   559 } // End namespace detail.

   560 

   561 } } // End namespaces iostreams, boost.

   562 

   563 #endif // #ifndef BOOST_IOSTREAMS_DETAIL_CHAIN_HPP_INCLUDED