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 */ 22 namespace 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 time_point_get(size_t refs=0)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> get(iter_type i,iter_type e,std::ios_base & is,std::ios_base::iostate & err,time_point<Clock,Duration> & tp,const char_type * pattern,const char_type * pat_end) const101 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> get(time_point_units<CharT> const & facet,iter_type s,iter_type end,std::ios_base & ios,std::ios_base::iostate & err,time_point<Clock,Duration> & tp,const char_type * pattern,const char_type * pat_end) const117 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> get(iter_type i,iter_type e,std::ios_base & is,std::ios_base::iostate & err,time_point<Clock,Duration> & tp) const216 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> get_duration(iter_type i,iter_type e,std::ios_base & is,std::ios_base::iostate & err,duration<Rep,Period> & d) const243 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> get_duration(duration_get<CharT> const & facet,iter_type s,iter_type end,std::ios_base & ios,std::ios_base::iostate & err,duration<Rep,Period> & d) const259 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> get_epoch(iter_type i,iter_type e,std::ios_base & is,std::ios_base::iostate & err) const277 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> get_epoch(time_point_units<CharT> const & facet,iter_type i,iter_type e,std::ios_base &,std::ios_base::iostate & err) const292 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 */ ~time_point_get()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