ceph/src/boost/libs/iostreams/include/boost/iostreams/write.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_WRITE_HPP_INCLUDED
   9 #define BOOST_IOSTREAMS_WRITE_HPP_INCLUDED
  10
  11 #if defined(_MSC_VER)
  12 # pragma once
  13 #endif
  14
  15 #include <boost/config.hpp>  // DEDUCED_TYPENAME, MSVC.
  16 #include <boost/detail/workaround.hpp>
  17 #include <boost/iostreams/categories.hpp>
  18 #include <boost/iostreams/detail/char_traits.hpp>
  19 #include <boost/iostreams/detail/dispatch.hpp>
  20 #include <boost/iostreams/detail/ios.hpp>  // streamsize.
  21 #include <boost/iostreams/detail/streambuf.hpp>
  22 #include <boost/iostreams/detail/wrap_unwrap.hpp>
  23 #include <boost/iostreams/operations_fwd.hpp>
  24 #include <boost/iostreams/traits.hpp>
  25 #include <boost/mpl/if.hpp>
  26
  27 // Must come last.
  28 #include <boost/iostreams/detail/config/disable_warnings.hpp>
  29
  30 namespace boost { namespace iostreams {
  31
  32 namespace detail {
  33
  34 template<typename T>
  35 struct write_device_impl;
  36
  37 template<typename T>
  38 struct write_filter_impl;
  39
  40 } // End namespace detail.
  41
  42 template<typename T>
  43 bool put(T& t, typename char_type_of<T>::type c)
  44 { return detail::write_device_impl<T>::put(detail::unwrap(t), c); }
  45
  46 template<typename T>
  47 inline std::streamsize write
  48     (T& t, const typename char_type_of<T>::type* s, std::streamsize n)
  49 { return detail::write_device_impl<T>::write(detail::unwrap(t), s, n); }
  50
  51 template<typename T, typename Sink>
  52 inline std::streamsize
  53 write( T& t, Sink& snk, const typename char_type_of<T>::type* s,
  54        std::streamsize n )
  55 { return detail::write_filter_impl<T>::write(detail::unwrap(t), snk, s, n); }
  56
  57 namespace detail {
  58
  59 //------------------Definition of write_device_impl---------------------------//
  60
  61 template<typename T>
  62 struct write_device_impl
  63     : mpl::if_<
  64           is_custom<T>,
  65           operations<T>,
  66           write_device_impl<
  67               BOOST_DEDUCED_TYPENAME
  68               dispatch<
  69                   T, ostream_tag, streambuf_tag, output
  70               >::type
  71           >
  72       >::type
  73     { };
  74
  75 template<>
  76 struct write_device_impl<ostream_tag> {
  77     template<typename T>
  78     static bool put(T& t, typename char_type_of<T>::type c)
  79     {
  80         typedef typename char_type_of<T>::type          char_type;
  81         typedef BOOST_IOSTREAMS_CHAR_TRAITS(char_type)  traits_type;
  82         return !traits_type::eq_int_type( t.rdbuf()->sputc(c),
  83                                           traits_type::eof() );
  84     }
  85
  86     template<typename T>
  87     static std::streamsize write
  88         (T& t, const typename char_type_of<T>::type* s, std::streamsize n)
  89     { return t.rdbuf()->sputn(s, n); }
  90 };
  91
  92 template<>
  93 struct write_device_impl<streambuf_tag> {
  94     template<typename T>
  95     static bool put(T& t, typename char_type_of<T>::type c)
  96     {
  97         typedef typename char_type_of<T>::type          char_type;
  98         typedef BOOST_IOSTREAMS_CHAR_TRAITS(char_type)  traits_type;
  99         return !traits_type::eq_int_type(t.sputc(c), traits_type::eof());
 100     }
 101
 102     template<typename T>
 103     static std::streamsize write
 104         (T& t, const typename char_type_of<T>::type* s, std::streamsize n)
 105     { return t.sputn(s, n); }
 106 };
 107
 108 template<>
 109 struct write_device_impl<output> {
 110     template<typename T>
 111     static bool put(T& t, typename char_type_of<T>::type c)
 112     { return t.write(&c, 1) == 1; }
 113
 114     template<typename T>
 115     static std::streamsize
 116     write(T& t, const typename char_type_of<T>::type* s, std::streamsize n)
 117     { return t.write(s, n); }
 118 };
 119
 120 //------------------Definition of write_filter_impl---------------------------//
 121
 122 template<typename T>
 123 struct write_filter_impl
 124     : mpl::if_<
 125           is_custom<T>,
 126           operations<T>,
 127           write_filter_impl<
 128               BOOST_DEDUCED_TYPENAME
 129               dispatch<
 130                   T, multichar_tag, any_tag
 131               >::type
 132           >
 133       >::type
 134     { };
 135
 136 template<>
 137 struct write_filter_impl<multichar_tag> {
 138     template<typename T, typename Sink>
 139     static std::streamsize
 140     write( T& t, Sink& snk, const typename char_type_of<T>::type* s,
 141            std::streamsize n )
 142     { return t.write(snk, s, n); }
 143 };
 144
 145 template<>
 146 struct write_filter_impl<any_tag> {
 147     template<typename T, typename Sink>
 148     static std::streamsize
 149     write( T& t, Sink& snk, const typename char_type_of<T>::type* s,
 150            std::streamsize n )
 151     {
 152         for (std::streamsize off = 0; off < n; ++off)
 153             if (!t.put(snk, s[off]))
 154                 return off;
 155         return n;
 156     }
 157 };
 158
 159 } // End namespace detail.
 160
 161 } } // End namespaces iostreams, boost.
 162
 163 #include <boost/iostreams/detail/config/enable_warnings.hpp>
 164
 165 #endif // #ifndef BOOST_IOSTREAMS_WRITE_HPP_INCLUDED