// (C) Copyright Jonathan Turkanis 2003.

 // Distributed under 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/iostreams for documentation.

 #ifndef BOOST_IOSTREAMS_STREAM_BUFFER_HPP_INCLUDED

 #define BOOST_IOSTREAMS_STREAM_BUFFER_HPP_INCLUDED

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

 # pragma once

 #endif

 #include <memory>            // allocator.

 #include <boost/config.hpp>  // BOOST_DEDUCED_TYPENAME.

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

 #include <boost/iostreams/detail/config/overload_resolution.hpp>

 #include <boost/iostreams/detail/forward.hpp>

 #include <boost/iostreams/detail/ios.hpp>  // failure, streamsize.

 #include <boost/iostreams/detail/streambuf/direct_streambuf.hpp>

 #include <boost/iostreams/detail/streambuf/indirect_streambuf.hpp>

 #include <boost/iostreams/traits.hpp>

 #include <boost/static_assert.hpp>

 #include <boost/type_traits/is_convertible.hpp>

 // Must come last.

 #include <boost/iostreams/detail/config/disable_warnings.hpp>  // MSVC.

 namespace boost { namespace iostreams { namespace detail {

 template<typename T, typename Tr, typename Alloc, typename Mode>

 struct stream_buffer_traits {

     typedef typename

             mpl::if_<

                 is_convertible<

                     BOOST_DEDUCED_TYPENAME category_of<T>::type,

                     direct_tag

                 >,

                 direct_streambuf<T, Tr>,

                 indirect_streambuf<T, Tr, Alloc, Mode>

             >::type type;

 };

 } } } // End namespaces detail, iostreams, boost

 #ifdef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION

 # include <boost/iostreams/detail/broken_overload_resolution/stream_buffer.hpp>

 #else

 namespace boost { namespace iostreams {

 template< typename T,

           typename Tr =

               BOOST_IOSTREAMS_CHAR_TRAITS(

                   BOOST_DEDUCED_TYPENAME char_type_of<T>::type

               ),

           typename Alloc =

               std::allocator<

                   BOOST_DEDUCED_TYPENAME char_type_of<T>::type

               >,

           typename Mode = BOOST_DEDUCED_TYPENAME mode_of<T>::type >

 class stream_buffer

     : public detail::stream_buffer_traits<T, Tr, Alloc, Mode>::type

 {

 private:

     BOOST_STATIC_ASSERT((

         is_convertible<

             BOOST_DEDUCED_TYPENAME iostreams::category_of<T>::type, Mode

         >::value

     ));

     typedef typename

             detail::stream_buffer_traits<

                 T, Tr, Alloc, Mode

             >::type                           base_type;

     typedef T                                 policy_type;

 public:

     typedef typename char_type_of<T>::type    char_type;

     BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)

 public:

     stream_buffer() { }

     ~stream_buffer()

     { 

         try { 

             if (this->is_open() && this->auto_close()) 

                 this->close(); 

         } catch (std::exception&) { } 

     }

     BOOST_IOSTREAMS_FORWARD( stream_buffer, open_impl, T,

                              BOOST_IOSTREAMS_PUSH_PARAMS,

                              BOOST_IOSTREAMS_PUSH_ARGS )

     T& operator*() { return *this->component(); }

     T* operator->() { return this->component(); }

 private:

     void open_impl(const T& t BOOST_IOSTREAMS_PUSH_PARAMS())

         {   // Used for forwarding.

             if (this->is_open())

                 BOOST_IOSTREAMS_FAILURE("already open");

             base_type::open(t BOOST_IOSTREAMS_PUSH_ARGS());

         }

 };

 } } // End namespaces iostreams, boost.

 #endif // #ifdef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION

 #include <boost/iostreams/detail/config/enable_warnings.hpp>  // MSVC.

 #endif // #ifndef BOOST_IOSTREAMS_STREAM_BUFFER_HPP_INCLUDED