]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com) |
2 | // (C) Copyright 2005-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_READ_HPP_INCLUDED | |
9 | #define BOOST_IOSTREAMS_READ_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/char_traits.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/mpl/if.hpp> | |
25 | ||
26 | // Must come last. | |
27 | #include <boost/iostreams/detail/config/disable_warnings.hpp> | |
28 | ||
29 | namespace boost { namespace iostreams { | |
30 | ||
31 | namespace detail { | |
32 | ||
33 | template<typename T> | |
34 | struct read_device_impl; | |
35 | ||
36 | template<typename T> | |
37 | struct read_filter_impl; | |
38 | ||
39 | } // End namespace detail. | |
40 | ||
41 | template<typename T> | |
42 | typename int_type_of<T>::type get(T& t) | |
43 | { return detail::read_device_impl<T>::get(detail::unwrap(t)); } | |
44 | ||
45 | template<typename T> | |
46 | inline std::streamsize | |
47 | read(T& t, typename char_type_of<T>::type* s, std::streamsize n) | |
48 | { return detail::read_device_impl<T>::read(detail::unwrap(t), s, n); } | |
49 | ||
50 | template<typename T, typename Source> | |
51 | std::streamsize | |
52 | read(T& t, Source& src, typename char_type_of<T>::type* s, std::streamsize n) | |
53 | { return detail::read_filter_impl<T>::read(detail::unwrap(t), src, s, n); } | |
54 | ||
55 | template<typename T> | |
56 | bool putback(T& t, typename char_type_of<T>::type c) | |
57 | { return detail::read_device_impl<T>::putback(detail::unwrap(t), c); } | |
58 | ||
59 | //----------------------------------------------------------------------------// | |
60 | ||
61 | namespace detail { | |
62 | ||
63 | // Helper function for adding -1 as EOF indicator. | |
64 | inline std::streamsize check_eof(std::streamsize n) { return n != 0 ? n : -1; } | |
65 | ||
66 | // Helper templates for reading from streambufs. | |
67 | template<bool IsLinked> | |
68 | struct true_eof_impl; | |
69 | ||
70 | template<> | |
71 | struct true_eof_impl<true> { | |
72 | template<typename T> | |
73 | static bool true_eof(T& t) { return t.true_eof(); } | |
74 | }; | |
75 | ||
76 | template<> | |
77 | struct true_eof_impl<false> { | |
78 | template<typename T> | |
79 | static bool true_eof(T&) { return true; } | |
80 | }; | |
81 | ||
82 | template<typename T> | |
83 | inline bool true_eof(T& t) | |
84 | { | |
85 | const bool linked = is_linked<T>::value; | |
86 | return true_eof_impl<linked>::true_eof(t); | |
87 | } | |
88 | ||
89 | //------------------Definition of read_device_impl----------------------------// | |
90 | ||
91 | template<typename T> | |
92 | struct read_device_impl | |
93 | : mpl::if_< | |
94 | detail::is_custom<T>, | |
95 | operations<T>, | |
96 | read_device_impl< | |
97 | BOOST_DEDUCED_TYPENAME | |
98 | detail::dispatch< | |
99 | T, istream_tag, streambuf_tag, input | |
100 | >::type | |
101 | > | |
102 | >::type | |
103 | { }; | |
104 | ||
105 | template<> | |
106 | struct read_device_impl<istream_tag> { | |
107 | template<typename T> | |
108 | static typename int_type_of<T>::type get(T& t) | |
109 | { return t.get(); } | |
110 | ||
111 | template<typename T> | |
112 | static std::streamsize | |
113 | read(T& t, typename char_type_of<T>::type* s, std::streamsize n) | |
114 | { return check_eof(t.rdbuf()->sgetn(s, n)); } | |
115 | ||
116 | template<typename T> | |
117 | static bool putback(T& t, typename char_type_of<T>::type c) | |
118 | { | |
119 | typedef typename char_type_of<T>::type char_type; | |
120 | typedef BOOST_IOSTREAMS_CHAR_TRAITS(char_type) traits_type; | |
121 | return !traits_type::eq_int_type( t.rdbuf()->sputbackc(c), | |
122 | traits_type::eof() ); | |
123 | } | |
124 | }; | |
125 | ||
126 | template<> | |
127 | struct read_device_impl<streambuf_tag> { | |
128 | template<typename T> | |
129 | static typename int_type_of<T>::type | |
130 | get(T& t) | |
131 | { // gcc 2.95 needs namespace qualification for char_traits. | |
132 | typedef typename char_type_of<T>::type char_type; | |
133 | typedef iostreams::char_traits<char_type> traits_type; | |
134 | typename int_type_of<T>::type c; | |
135 | return !traits_type::is_eof(c = t.sbumpc()) || | |
136 | detail::true_eof(t) | |
137 | ? | |
138 | c : traits_type::would_block(); | |
139 | } | |
140 | ||
141 | template<typename T> | |
142 | static std::streamsize | |
143 | read(T& t, typename char_type_of<T>::type* s, std::streamsize n) | |
144 | { | |
145 | std::streamsize amt; | |
146 | return (amt = t.sgetn(s, n)) != 0 ? | |
147 | amt : | |
148 | detail::true_eof(t) ? | |
149 | -1 : | |
150 | 0; | |
151 | } | |
152 | ||
153 | template<typename T> | |
154 | static bool putback(T& t, typename char_type_of<T>::type c) | |
155 | { // gcc 2.95 needs namespace qualification for char_traits. | |
156 | typedef typename char_type_of<T>::type char_type; | |
157 | typedef iostreams::char_traits<char_type> traits_type; | |
158 | return !traits_type::is_eof(t.sputbackc(c)); | |
159 | } | |
160 | }; | |
161 | ||
162 | template<> | |
163 | struct read_device_impl<input> { | |
164 | template<typename T> | |
165 | static typename int_type_of<T>::type | |
166 | get(T& t) | |
167 | { // gcc 2.95 needs namespace qualification for char_traits. | |
168 | typedef typename char_type_of<T>::type char_type; | |
169 | typedef iostreams::char_traits<char_type> traits_type; | |
170 | char_type c; | |
171 | std::streamsize amt; | |
172 | return (amt = t.read(&c, 1)) == 1 ? | |
173 | traits_type::to_int_type(c) : | |
174 | amt == -1 ? | |
175 | traits_type::eof() : | |
176 | traits_type::would_block(); | |
177 | } | |
178 | ||
179 | template<typename T> | |
180 | static std::streamsize | |
181 | read(T& t, typename char_type_of<T>::type* s, std::streamsize n) | |
182 | { return t.read(s, n); } | |
183 | ||
184 | template<typename T> | |
185 | static bool putback(T& t, typename char_type_of<T>::type c) | |
186 | { // T must be Peekable. | |
187 | return t.putback(c); | |
188 | } | |
189 | }; | |
190 | ||
191 | //------------------Definition of read_filter_impl----------------------------// | |
192 | ||
193 | template<typename T> | |
194 | struct read_filter_impl | |
195 | : mpl::if_< | |
196 | detail::is_custom<T>, | |
197 | operations<T>, | |
198 | read_filter_impl< | |
199 | BOOST_DEDUCED_TYPENAME | |
200 | detail::dispatch< | |
201 | T, multichar_tag, any_tag | |
202 | >::type | |
203 | > | |
204 | >::type | |
205 | { }; | |
206 | ||
207 | template<> | |
208 | struct read_filter_impl<multichar_tag> { | |
209 | template<typename T, typename Source> | |
210 | static std::streamsize read | |
211 | (T& t, Source& src, typename char_type_of<T>::type* s, std::streamsize n) | |
212 | { return t.read(src, s, n); } | |
213 | }; | |
214 | ||
215 | template<> | |
216 | struct read_filter_impl<any_tag> { | |
217 | template<typename T, typename Source> | |
218 | static std::streamsize read | |
219 | (T& t, Source& src, typename char_type_of<T>::type* s, std::streamsize n) | |
220 | { // gcc 2.95 needs namespace qualification for char_traits. | |
221 | typedef typename char_type_of<T>::type char_type; | |
222 | typedef iostreams::char_traits<char_type> traits_type; | |
223 | for (std::streamsize off = 0; off < n; ++off) { | |
224 | typename traits_type::int_type c = t.get(src); | |
225 | if (traits_type::is_eof(c)) | |
226 | return check_eof(off); | |
227 | if (traits_type::would_block(c)) | |
228 | return off; | |
229 | s[off] = traits_type::to_char_type(c); | |
230 | } | |
231 | return n; | |
232 | } | |
233 | }; | |
234 | ||
235 | } // End namespace detail. | |
236 | ||
237 | } } // End namespaces iostreams, boost. | |
238 | ||
239 | #include <boost/iostreams/detail/config/enable_warnings.hpp> | |
240 | ||
241 | #endif // #ifndef BOOST_IOSTREAMS_READ_HPP_INCLUDED |