boost/iostreams/detail/broken_overload_resolution/stream_buffer.hpp

   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_BROKEN_OVERLOAD_RESOLUTION_STREAM_BUFFER_HPP_INCLUDED
   9 #define BOOST_IOSTREAMS_DETAIL_BROKEN_OVERLOAD_RESOLUTION_STREAM_BUFFER_HPP_INCLUDED
  10
  11 #include <boost/iostreams/detail/broken_overload_resolution/forward.hpp>
  12
  13 namespace boost { namespace iostreams {
  14
  15 template< typename T,
  16           typename Tr =
  17               BOOST_IOSTREAMS_CHAR_TRAITS(
  18                   BOOST_DEDUCED_TYPENAME char_type_of<T>::type
  19               ),
  20           typename Alloc =
  21               std::allocator<
  22                   BOOST_DEDUCED_TYPENAME char_type_of<T>::type
  23               >,
  24           typename Mode = BOOST_DEDUCED_TYPENAME mode_of<T>::type >
  25 class stream_buffer
  26     : public detail::stream_buffer_traits<T, Tr, Alloc, Mode>::type
  27 {
  28 private:
  29     BOOST_STATIC_ASSERT((
  30         is_convertible<
  31             BOOST_DEDUCED_TYPENAME iostreams::category_of<T>::type, Mode
  32         >::value
  33     ));
  34     typedef typename
  35             detail::stream_buffer_traits<
  36                 T, Tr, Alloc, Mode
  37             >::type                           base_type;
  38 public:
  39     typedef typename char_type_of<T>::type    char_type;
  40     struct category
  41         : Mode,
  42           closable_tag,
  43           streambuf_tag
  44         { };
  45     BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)
  46     stream_buffer() { }
  47     ~stream_buffer()
  48     {
  49         try {
  50             if (this->is_open() && this->auto_close())
  51                 this->close();
  52         } catch (...) { }
  53     }
  54     template<typename U0>
  55     stream_buffer(const U0& u0)
  56     {
  57         open_impl(detail::forward<T, U0>(), u0);
  58     }
  59     template<typename U0, typename U1>
  60     stream_buffer(const U0& u0, const U1& u1)
  61     {
  62         open_impl(detail::forward<T, U0>(), u0, u1);
  63     }
  64     template<typename U0, typename U1, typename U2>
  65     stream_buffer(const U0& u0, const U1& u1, const U2& u2)
  66     {
  67         open_impl(detail::forward<T, U0>(), u0, u1, u2);
  68     }
  69 #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
  70     template<typename U0>
  71     stream_buffer(U0& u0)
  72     {
  73         open_impl(detail::forward<T, U0>(), u0);
  74     }
  75     template<typename U0, typename U1>
  76     stream_buffer(U0& u0, const U1& u1)
  77     {
  78         open_impl(detail::forward<T, U0>(), u0, u1);
  79     }
  80     template<typename U0, typename U1, typename U2>
  81     stream_buffer(U0& u0, const U1& u1, const U2& u2)
  82     {
  83         open_impl(detail::forward<T, U0>(), u0, u1, u2);
  84     }
  85 #endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
  86     template<typename U0>
  87     void open(const U0& u0)
  88     {
  89         open_impl(detail::forward<T, U0>(), u0);
  90     }
  91     template<typename U0, typename U1>
  92     void open(const U0& u0, const U1& u1)
  93     {
  94         open_impl(detail::forward<T, U0>(), u0, u1);
  95     }
  96     template<typename U0, typename U1, typename U2>
  97     void open(const U0& u0, const U1& u1, const U2& u2)
  98     {
  99         open_impl(detail::forward<T, U0>(), u0, u1, u2);
 100     }
 101 #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
 102     template<typename U0>
 103     void open(U0& u0)
 104     {
 105         open_impl(detail::forward<T, U0>(), u0);
 106     }
 107     template<typename U0, typename U1>
 108     void open(U0& u0, const U1& u1)
 109     {
 110         open_impl(detail::forward<T, U0>(), u0, u1);
 111     }
 112     template<typename U0, typename U1, typename U2>
 113     void open(U0& u0, const U1& u1, const U2& u2)
 114     {
 115         open_impl(detail::forward<T, U0>(), u0, u1, u2);
 116     }
 117 #endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
 118     T& operator*() { return *this->component(); }
 119     T* operator->() { return this->component(); }
 120 private:
 121     template<typename U0>
 122     void open_impl(mpl::false_, const U0& u0)
 123     {
 124         base_type::open(const_cast<U0&>(u0), -1, -1);
 125     }
 126 #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
 127     template<typename U0>
 128     void open_impl(mpl::false_, U0& u0)
 129     {
 130         base_type::open(detail::wrap(u0), -1, -1);
 131     }
 132 #endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
 133     template<typename U0>
 134     void open_impl(mpl::true_, const U0& u0)
 135     {
 136         base_type::open(T(const_cast<U0&>(u0)), -1, -1);
 137     }
 138 #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
 139     template<typename U0>
 140     void open_impl(mpl::true_, U0& u0)
 141     {
 142         base_type::open(T(u0), -1, -1);
 143     }
 144 #endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
 145     template<typename U0, typename U1>
 146     void open_impl(mpl::false_, const U0& u0, const U1& u1)
 147     {
 148         base_type::open(u0, u1, -1);
 149     }
 150     template<typename U0, typename U1>
 151     void open_impl(mpl::true_, const U0& u0, const U1& u1)
 152     {
 153         base_type::open(T(const_cast<U0&>(u0), u1), -1, -1);
 154     }
 155 #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
 156     template<typename U0, typename U1>
 157     void open_impl(mpl::true_, U0& u0, const U1& u1)
 158     {
 159         base_type::open(T(u0, u1), -1, -1);
 160     }
 161 #endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
 162     template<typename U0, typename U1, typename U2>
 163     void open_impl(mpl::false_, const U0& u0, const U1& u1, const U2& u2)
 164     {
 165         base_type::open(u0, u1, u2);
 166     }
 167     template<typename U0, typename U1, typename U2>
 168     void open_impl(mpl::true_, const U0& u0, const U1& u1, const U2& u2)
 169     {
 170         base_type::open(T(const_cast<U0&>(u0), u1, u2), -1, -1);
 171     }
 172 #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
 173     template<typename U0, typename U1, typename U2>
 174     void open_impl(mpl::true_, U0& u0, const U1& u1, const U2& u2)
 175     {
 176         base_type::open(T(u0, u1, u2), -1, -1);
 177     }
 178 #endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
 179     void check_open()
 180     {
 181         if (this->is_open())
 182             throw BOOST_IOSTREAMS_FAILURE("already open");
 183     }
 184 };
 185
 186 } } // End namespaces iostreams, boost.
 187
 188 #endif // BOOST_IOSTREAMS_DETAIL_BROKEN_OVERLOAD_RESOLUTION_STREAM_BUFFER_HPP_INCLUDED