1// (C) Copyright Howard Hinnant
2// (C) Copyright 2011 Vicente J. Botet Escriba
3// Use, modification and distribution are subject to the Boost Software License,
4// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
5// http://www.boost.org/LICENSE_1_0.txt).
6//
7
8#ifndef BOOST_CHRONO_IO_TIME_POINT_GET_HPP
9#define BOOST_CHRONO_IO_TIME_POINT_GET_HPP
10
11#include <boost/chrono/config.hpp>
12#include <boost/chrono/detail/scan_keyword.hpp>
13#include <boost/chrono/io/time_point_units.hpp>
14#include <boost/chrono/io/duration_get.hpp>
15#include <boost/assert.hpp>
16#include <locale>
17#include <string>
18
19/**
20 * Duration formatting facet for input.
21 */
22namespace boost
23{
24 namespace chrono
25 {
26
27 template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> >
28 class time_point_get: public std::locale::facet
29 {
30 public:
31 /**
32 * Type of character the facet is instantiated on.
33 */
34 typedef CharT char_type;
35 /**
36 * Type of iterator used to scan the character buffer.
37 */
38 typedef InputIterator iter_type;
39
40 /**
41 * Construct a @c time_point_get facet.
42 * @param refs
43 * @Effects Construct a @c time_point_get facet.
44 * If the @c refs argument is @c 0 then destruction of the object is
45 * delegated to the @c locale, or locales, containing it. This allows
46 * the user to ignore lifetime management issues. On the other had,
47 * if @c refs is @c 1 then the object must be explicitly deleted;
48 * the @c locale will not do so. In this case, the object can be
49 * maintained across the lifetime of multiple locales.
50 */
51
52 explicit time_point_get(size_t refs = 0) :
53 std::locale::facet(refs)
54 {
55 }
56
57 /**
58 * @param s start input stream iterator
59 * @param end end input stream iterator
60 * @param ios a reference to a ios_base
61 * @param err the ios_base state
62 * @param d the duration
63 * @param pattern begin of the formatting pattern
64 * @param pat_end end of the formatting pattern
65 *
66 * Requires: [pattern,pat_end) shall be a valid range.
67 *
68 * Effects: The function starts by evaluating err = std::ios_base::goodbit.
69 * It then enters a loop, reading zero or more characters from s at
70 * each iteration. Unless otherwise specified below, the loop
71 * terminates when the first of the following conditions holds:
72 * - The expression pattern == pat_end evaluates to true.
73 * - The expression err == std::ios_base::goodbit evaluates to false.
74 * - The expression s == end evaluates to true, in which case the
75 * function evaluates err = std::ios_base::eofbit | std::ios_base::failbit.
76 * - The next element of pattern is equal to '%', followed by a conversion
77 * specifier character, the functions @c get_duration or @c get_epoch are called depending on
78 * whether the format is @c 'd' or @c 'e'.
79 * If the number of elements in the range [pattern,pat_end) is not
80 * sufficient to unambiguously determine whether the conversion
81 * specification is complete and valid, the function evaluates
82 * err = std::ios_base::failbit. Otherwise, the function evaluates
83 * s = do_get(s, end, ios, err, d). If err == std::ios_base::goodbit holds after
84 * the evaluation of the expression, the function increments pattern to
85 * point just past the end of the conversion specification and continues
86 * looping.
87 * - The expression isspace(*pattern, ios.getloc()) evaluates to true, in
88 * which case the function first increments pattern until
89 * pattern == pat_end || !isspace(*pattern, ios.getloc()) evaluates to true,
90 * then advances s until s == end || !isspace(*s, ios.getloc()) is true,
91 * and finally resumes looping.
92 * - The next character read from s matches the element pointed to by
93 * pattern in a case-insensitive comparison, in which case the function
94 * evaluates ++pattern, ++s and continues looping. Otherwise, the function
95 * evaluates err = std::ios_base::failbit.
96 *
97 * Returns: s
98 */
99
100 template <class Clock, class Duration>
101 iter_type get(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err,
102 time_point<Clock, Duration> &tp, const char_type *pattern, const char_type *pat_end) const
103 {
104 if (std::has_facet<time_point_units<CharT> >(is.getloc()))
105 {
106 time_point_units<CharT> const &facet = std::use_facet<time_point_units<CharT> >(is.getloc());
107 return get(facet, i, e, is, err, tp, pattern, pat_end);
108 }
109 else
110 {
111 time_point_units_default<CharT> facet;
112 return get(facet, i, e, is, err, tp, pattern, pat_end);
113 }
114 }
115
116 template <class Clock, class Duration>
117 iter_type get(time_point_units<CharT> const &facet, iter_type s, iter_type end, std::ios_base& ios,
118 std::ios_base::iostate& err, time_point<Clock, Duration> &tp, const char_type *pattern,
119 const char_type *pat_end) const
120 {
121
122 Duration d;
123 bool duration_found = false, epoch_found = false;
124
125 const std::ctype<char_type>& ct = std::use_facet<std::ctype<char_type> >(ios.getloc());
126 err = std::ios_base::goodbit;
127 while (pattern != pat_end && err == std::ios_base::goodbit)
128 {
129 if (s == end)
130 {
131 err |= std::ios_base::eofbit;
132 break;
133 }
134 if (ct.narrow(*pattern, 0) == '%')
135 {
136 if (++pattern == pat_end)
137 {
138 err |= std::ios_base::failbit;
139 return s;
140 }
141 char cmd = ct.narrow(*pattern, 0);
142 switch (cmd)
143 {
144 case 'd':
145 {
146 if (duration_found)
147 {
148 err |= std::ios_base::failbit;
149 return s;
150 }
151 duration_found = true;
152 s = get_duration(s, end, ios, err, d);
153 if (err & (std::ios_base::badbit | std::ios_base::failbit))
154 {
155 return s;
156 }
157 break;
158 }
159 case 'e':
160 {
161 if (epoch_found)
162 {
163 err |= std::ios_base::failbit;
164 return s;
165 }
166 epoch_found = true;
167 s = get_epoch<Clock> (facet, s, end, ios, err);
168 if (err & (std::ios_base::badbit | std::ios_base::failbit))
169 {
170 return s;
171 }
172 break;
173 }
174 default:
175 BOOST_ASSERT(false && "Boost::Chrono internal error.");
176 break;
177 }
178
179 ++pattern;
180 }
181 else if (ct.is(std::ctype_base::space, *pattern))
182 {
183 for (++pattern; pattern != pat_end && ct.is(std::ctype_base::space, *pattern); ++pattern)
184 ;
185 for (; s != end && ct.is(std::ctype_base::space, *s); ++s)
186 ;
187 }
188 else if (ct.toupper(*s) == ct.toupper(*pattern))
189 {
190 ++s;
191 ++pattern;
192 }
193 else
194 {
195 err |= std::ios_base::failbit;
196 }
197 }
198
199 // Success! Store it.
200 tp = time_point<Clock, Duration> (d);
201 return s;
202 }
203
204 /**
205 *
206 * @param s an input stream iterator
207 * @param ios a reference to a ios_base
208 * @param d the duration
209 * Stores the duration pattern from the @c duration_unit facet in let say @c str. Last as if
210 * @code
211 * return get(s, end, ios, err, ios, d, str.data(), str.data() + str.size());
212 * @codeend
213 * @Returns An iterator pointing just beyond the last character that can be determined to be part of a valid name
214 */
215 template <class Clock, class Duration>
216 iter_type get(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err,
217 time_point<Clock, Duration> &tp) const
218 {
219 if (std::has_facet<time_point_units<CharT> >(is.getloc()))
220 {
221 time_point_units<CharT> const &facet = std::use_facet<time_point_units<CharT> >(is.getloc());
222 std::basic_string<CharT> str = facet.get_pattern();
223 return get(facet, i, e, is, err, tp, str.data(), str.data() + str.size());
224 }
225 else
226 {
227 time_point_units_default<CharT> facet;
228 std::basic_string<CharT> str = facet.get_pattern();
229 return get(facet, i, e, is, err, tp, str.data(), str.data() + str.size());
230 }
231 }
232
233 /**
234 * As if
235 * @code
236 * return facet.get(s, end, ios, err, d);
237 * @endcode
238 * where @c facet is either the @c duration_get facet associated to the @c ios or an instance of the default @c duration_get facet.
239 *
240 * @Returns An iterator pointing just beyond the last character that can be determined to be part of a valid duration.
241 */
242 template <typename Rep, typename Period>
243 iter_type get_duration(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err,
244 duration<Rep, Period>& d) const
245 {
246 if (std::has_facet<duration_get<CharT> >(is.getloc()))
247 {
248 duration_get<CharT> const &facet = std::use_facet<duration_get<CharT> >(is.getloc());
249 return get_duration(facet, i, e, is, err, d);
250 }
251 else
252 {
253 duration_get<CharT> facet;
254 return get_duration(facet, i, e, is, err, d);
255 }
256 }
257
258 template <typename Rep, typename Period>
259 iter_type get_duration(duration_get<CharT> const& facet, iter_type s, iter_type end, std::ios_base& ios,
260 std::ios_base::iostate& err, duration<Rep, Period>& d) const
261 {
262 return facet.get(s, end, ios, err, d);
263 }
264
265 /**
266 *
267 * @Effects Let @c facet be the @c time_point_units facet associated to @c is or a new instance of the default @c time_point_units_default facet.
268 * Let @c epoch be the epoch string associated to the Clock using this facet.
269 * Scans @c i to match @c epoch or @c e is reached.
270 *
271 * If not match before the @c e is reached @c std::ios_base::failbit is set in @c err.
272 * If @c e is reached @c std::ios_base::failbit is set in @c err.
273 *
274 * @Returns An iterator pointing just beyond the last character that can be determined to be part of a valid epoch.
275 */
276 template <class Clock>
277 iter_type get_epoch(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err) const
278 {
279 if (std::has_facet<time_point_units<CharT> >(is.getloc()))
280 {
281 time_point_units<CharT> const &facet = std::use_facet<time_point_units<CharT> >(is.getloc());
282 return get_epoch<Clock>(facet, i, e, is, err);
283 }
284 else
285 {
286 time_point_units_default<CharT> facet;
287 return get_epoch<Clock>(facet, i, e, is, err);
288 }
289 }
290
291 template <class Clock>
292 iter_type get_epoch(time_point_units<CharT> const &facet, iter_type i, iter_type e, std::ios_base&,
293 std::ios_base::iostate& err) const
294 {
295 const std::basic_string<CharT> epoch = facet.template get_epoch<Clock> ();
296 std::ptrdiff_t k = chrono_detail::scan_keyword(i, e, &epoch, &epoch + 1,
297 //~ std::use_facet<std::ctype<CharT> >(ios.getloc()),
298 err) - &epoch;
299 if (k == 1)
300 {
301 err |= std::ios_base::failbit;
302 return i;
303 }
304 return i;
305 }
306
307 /**
308 * Unique identifier for this type of facet.
309 */
310 static std::locale::id id;
311
312 /**
313 * @Effects Destroy the facet
314 */
315 ~time_point_get()
316 {
317 }
318 };
319
320 /**
321 * Unique identifier for this type of facet.
322 */
323 template <class CharT, class InputIterator>
324 std::locale::id time_point_get<CharT, InputIterator>::id;
325
326 } // chrono
327}
328// boost
329
330#endif // header
331

source code of boost/libs/chrono/include/boost/chrono/io/time_point_get.hpp