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
30namespace boost { namespace iostreams {
31
32namespace detail {
33
34template<typename T>
35struct write_device_impl;
36
37template<typename T>
38struct write_filter_impl;
39
40} // End namespace detail.
41
42template<typename T>
43bool put(T& t, typename char_type_of<T>::type c)
44{ return detail::write_device_impl<T>::put(detail::unwrap(t), c); }
45
46template<typename T>
47inline 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
51template<typename T, typename Sink>
52inline std::streamsize
53write( 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
57namespace detail {
58
59//------------------Definition of write_device_impl---------------------------//
60
61template<typename T>
62struct 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
75template<>
76struct 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
92template<>
93struct 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
108template<>
109struct 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
122template<typename T>
123struct 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
136template<>
137struct 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
145template<>
146struct 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
166

source code of boost/libs/iostreams/include/boost/iostreams/write.hpp