Mercurial > hg > vamp-build-and-test

comparison DEPENDENCIES/generic/include/boost/fusion/sequence/io/detail/manip.hpp @ 16:2665513ce2d3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add boost headers
author Chris Cannam
date Tue, 05 Aug 2014 11:11:38 +0100
parents
children c530137014c0
comparison
equal deleted inserted replaced
15:663ca0da4350 16:2665513ce2d3
1 /*=============================================================================
2 Copyright (c) 1999-2003 Jeremiah Willcock
3 Copyright (c) 1999-2003 Jaakko Jarvi
4 Copyright (c) 2001-2011 Joel de Guzman
5
6 Distributed under the Boost Software License, Version 1.0. (See accompanying
7 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
8 ==============================================================================*/
9 #if !defined(FUSION_MANIP_05052005_1200)
10 #define FUSION_MANIP_05052005_1200
11
12 #include <boost/config.hpp>
13 #include <string>
14 #include <vector>
15 #include <cctype>
16
17 // Tuple I/O manipulators
18
19 #define FUSION_GET_CHAR_TYPE(T) typename T::char_type
20 #define FUSION_GET_TRAITS_TYPE(T) typename T::traits_type
21
22 #if defined (BOOST_NO_TEMPLATED_STREAMS)
23 #define FUSION_STRING_OF_STREAM(Stream) std::string
24 #else
25 #define FUSION_STRING_OF_STREAM(Stream) \
26 std::basic_string< \
27 FUSION_GET_CHAR_TYPE(Stream) \
28 , FUSION_GET_TRAITS_TYPE(Stream) \
29 >
30 #endif
31
32 //$$$ these should be part of the public API$$$
33 //$$$ rename tuple_open, tuple_close and tuple_delimiter to
34 // open, close and delimeter and add these synonyms to the
35 // TR1 tuple module.
36
37 namespace boost { namespace fusion
38 {
39 namespace detail
40 {
41 template <typename Tag>
42 int get_xalloc_index(Tag* = 0)
43 {
44 // each Tag will have a unique index
45 static int index = std::ios::xalloc();
46 return index;
47 }
48
49 template <typename Stream, typename Tag, typename T>
50 struct stream_data
51 {
52 struct arena
53 {
54 ~arena()
55 {
56 for (
57 typename std::vector<T*>::iterator i = data.begin()
58 ; i != data.end()
59 ; ++i)
60 {
61 delete *i;
62 }
63 }
64
65 std::vector<T*> data;
66 };
67
68 static void attach(Stream& stream, T const& data)
69 {
70 static arena ar; // our arena
71 ar.data.push_back(new T(data));
72 stream.pword(get_xalloc_index<Tag>()) = ar.data.back();
73 }
74
75 static T const* get(Stream& stream)
76 {
77 return (T const*)stream.pword(get_xalloc_index<Tag>());
78 }
79 };
80
81 template <typename Tag, typename Stream>
82 class string_ios_manip
83 {
84 public:
85
86 typedef FUSION_STRING_OF_STREAM(Stream) string_type;
87
88 typedef stream_data<Stream, Tag, string_type> stream_data_t;
89
90 string_ios_manip(Stream& str_)
91 : stream(str_)
92 {}
93
94 void
95 set(string_type const& s)
96 {
97 stream_data_t::attach(stream, s);
98 }
99
100 void
101 print(char const* default_) const
102 {
103 // print a delimiter
104 string_type const* p = stream_data_t::get(stream);
105 if (p)
106 stream << *p;
107 else
108 stream << default_;
109 }
110
111 void
112 read(char const* default_) const
113 {
114 // read a delimiter
115 string_type const* p = stream_data_t::get(stream);
116 using namespace std;
117 ws(stream);
118
119 if (p)
120 {
121 typedef typename string_type::const_iterator iterator;
122 for (iterator i = p->begin(); i != p->end(); ++i)
123 check_delim(*i);
124 }
125 else
126 {
127 while (*default_)
128 check_delim(*default_++);
129 }
130 }
131
132 private:
133
134 template <typename Char>
135 void
136 check_delim(Char c) const
137 {
138 if (!isspace(c))
139 {
140 if (stream.get() != c)
141 {
142 stream.unget();
143 stream.setstate(std::ios::failbit);
144 }
145 }
146 }
147
148 Stream& stream;
149
150 private:
151 // silence MSVC warning C4512: assignment operator could not be generated
152 string_ios_manip& operator= (string_ios_manip const&);
153 };
154
155 } // detail
156
157 #if defined (BOOST_NO_TEMPLATED_STREAMS)
158
159 #define STD_TUPLE_DEFINE_MANIPULATOR(name) \
160 namespace detail \
161 { \
162 struct name##_tag; \
163 \
164 struct name##_type \
165 { \
166 typedef std::string string_type; \
167 string_type data; \
168 name##_type(const string_type& d): data(d) {} \
169 }; \
170 \
171 template <typename Stream> \
172 Stream& operator>>(Stream& s, const name##_type& m) \
173 { \
174 string_ios_manip<name##_tag, Stream>(s).set(m.data); \
175 return s; \
176 } \
177 \
178 template <typename Stream> \
179 Stream& operator<<(Stream& s, const name##_type& m) \
180 { \
181 string_ios_manip<name##_tag, Stream>(s).set(m.data); \
182 return s; \
183 } \
184 }
185
186 #define STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(name) \
187 inline detail::name##_type \
188 name(const std::string& s) \
189 { \
190 return detail::name##_type(s); \
191 } \
192 \
193 inline detail::name##_type \
194 name(const char* s) \
195 { \
196 return detail::name##_type(std::string(s)); \
197 } \
198 \
199 inline detail::name##_type \
200 name(char c) \
201 { \
202 return detail::name##_type(std::string(1, c)); \
203 }
204
205 #else // defined(BOOST_NO_TEMPLATED_STREAMS)
206
207 #if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
208
209 #define STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(name) \
210 template <typename Char, typename Traits> \
211 inline detail::name##_type<Char, Traits> \
212 name(const std::basic_string<Char, Traits>& s) \
213 { \
214 return detail::name##_type<Char, Traits>(s); \
215 } \
216 \
217 inline detail::name##_type<char> \
218 name(char const* s) \
219 { \
220 return detail::name##_type<char>(std::basic_string<char>(s)); \
221 } \
222 \
223 inline detail::name##_type<wchar_t> \
224 name(wchar_t const* s) \
225 { \
226 return detail::name##_type<wchar_t>(std::basic_string<wchar_t>(s)); \
227 } \
228 \
229 inline detail::name##_type<char> \
230 name(char c) \
231 { \
232 return detail::name##_type<char>(std::basic_string<char>(1, c)); \
233 } \
234 \
235 inline detail::name##_type<wchar_t> \
236 name(wchar_t c) \
237 { \
238 return detail::name##_type<wchar_t>(std::basic_string<wchar_t>(1, c)); \
239 }
240
241 #else // defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
242
243 #define STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(name) \
244 template <typename Char, typename Traits> \
245 inline detail::name##_type<Char, Traits> \
246 name(const std::basic_string<Char, Traits>& s) \
247 { \
248 return detail::name##_type<Char, Traits>(s); \
249 } \
250 \
251 template <typename Char> \
252 inline detail::name##_type<Char> \
253 name(Char s[]) \
254 { \
255 return detail::name##_type<Char>(std::basic_string<Char>(s)); \
256 } \
257 \
258 template <typename Char> \
259 inline detail::name##_type<Char> \
260 name(Char const s[]) \
261 { \
262 return detail::name##_type<Char>(std::basic_string<Char>(s)); \
263 } \
264 \
265 template <typename Char> \
266 inline detail::name##_type<Char> \
267 name(Char c) \
268 { \
269 return detail::name##_type<Char>(std::basic_string<Char>(1, c)); \
270 }
271
272 #endif
273
274 #define STD_TUPLE_DEFINE_MANIPULATOR(name) \
275 namespace detail \
276 { \
277 struct name##_tag; \
278 \
279 template <typename Char, typename Traits = std::char_traits<Char> > \
280 struct name##_type \
281 { \
282 typedef std::basic_string<Char, Traits> string_type; \
283 string_type data; \
284 name##_type(const string_type& d): data(d) {} \
285 }; \
286 \
287 template <typename Stream, typename Char, typename Traits> \
288 Stream& operator>>(Stream& s, const name##_type<Char,Traits>& m) \
289 { \
290 string_ios_manip<name##_tag, Stream>(s).set(m.data); \
291 return s; \
292 } \
293 \
294 template <typename Stream, typename Char, typename Traits> \
295 Stream& operator<<(Stream& s, const name##_type<Char,Traits>& m) \
296 { \
297 string_ios_manip<name##_tag, Stream>(s).set(m.data); \
298 return s; \
299 } \
300 } \
301
302 #endif // defined(BOOST_NO_TEMPLATED_STREAMS)
303
304 STD_TUPLE_DEFINE_MANIPULATOR(tuple_open)
305 STD_TUPLE_DEFINE_MANIPULATOR(tuple_close)
306 STD_TUPLE_DEFINE_MANIPULATOR(tuple_delimiter)
307
308 STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_open)
309 STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_close)
310 STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_delimiter)
311
312 #undef STD_TUPLE_DEFINE_MANIPULATOR
313 #undef STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS
314 #undef FUSION_STRING_OF_STREAM
315 #undef FUSION_GET_CHAR_TYPE
316 #undef FUSION_GET_TRAITS_TYPE
317
318 }}
319
320 #endif