]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /* |
2 | * Copyright Andrey Semashev 2007 - 2015. | |
3 | * Distributed under the Boost Software License, Version 1.0. | |
4 | * (See accompanying file LICENSE_1_0.txt or copy at | |
5 | * http://www.boost.org/LICENSE_1_0.txt) | |
6 | */ | |
7 | /*! | |
8 | * \file decomposed_time.hpp | |
9 | * \author Andrey Semashev | |
10 | * \date 07.11.2012 | |
11 | * | |
12 | * \brief This header is the Boost.Log library implementation, see the library documentation | |
13 | * at http://www.boost.org/doc/libs/release/libs/log/doc/html/index.html. | |
14 | */ | |
15 | ||
16 | #ifndef BOOST_LOG_DETAIL_DECOMPOSED_TIME_HPP_INCLUDED_ | |
17 | #define BOOST_LOG_DETAIL_DECOMPOSED_TIME_HPP_INCLUDED_ | |
18 | ||
19 | #include <ctime> | |
20 | #include <string> | |
21 | #include <vector> | |
22 | #include <locale> | |
23 | #include <boost/cstdint.hpp> | |
24 | #include <boost/move/core.hpp> | |
25 | #include <boost/range/iterator_range_core.hpp> | |
26 | #include <boost/log/detail/config.hpp> | |
27 | #include <boost/log/detail/date_time_format_parser.hpp> | |
28 | #include <boost/log/detail/attachable_sstream_buf.hpp> | |
29 | #include <boost/log/utility/formatting_ostream.hpp> | |
30 | #include <boost/log/detail/header.hpp> | |
31 | ||
32 | #ifdef BOOST_HAS_PRAGMA_ONCE | |
33 | #pragma once | |
34 | #endif | |
35 | ||
36 | namespace boost { | |
37 | ||
38 | BOOST_LOG_OPEN_NAMESPACE | |
39 | ||
40 | namespace aux { | |
41 | ||
42 | //! Date and time suitable for formatting | |
43 | struct decomposed_time | |
44 | { | |
45 | // Subseconds are microseconds | |
46 | enum _ | |
47 | { | |
48 | subseconds_per_second = 1000000, | |
49 | subseconds_digits10 = 6 | |
50 | }; | |
51 | ||
52 | uint32_t year, month, day, hours, minutes, seconds, subseconds; | |
53 | bool negative; | |
54 | ||
55 | decomposed_time() : year(0), month(1), day(1), hours(0), minutes(0), seconds(0), subseconds(0), negative(false) | |
56 | { | |
57 | } | |
58 | ||
59 | decomposed_time(uint32_t y, uint32_t mo, uint32_t d, uint32_t h, uint32_t mi, uint32_t s, uint32_t ss = 0, bool neg = false) : | |
60 | year(y), month(mo), day(d), hours(h), minutes(mi), seconds(s), subseconds(ss), negative(neg) | |
61 | { | |
62 | } | |
63 | ||
64 | unsigned int week_day() const | |
65 | { | |
66 | unsigned int a = (14u - month) / 12u; | |
67 | unsigned int y = year - a; | |
68 | unsigned int m = month + 12u * a - 2u; | |
69 | return (day + y + (y / 4u) - (y / 100u) + (y / 400u) + (31u * m) / 12u) % 7u; | |
70 | } | |
71 | ||
72 | unsigned int year_day() const | |
73 | { | |
74 | bool is_leap_year = (!(year % 4u)) && ((year % 100u) || (!(year % 400u))); | |
75 | static const unsigned int first_day_offset[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }; | |
76 | return first_day_offset[month - 1] + day + (month > 2 && is_leap_year); | |
77 | } | |
78 | }; | |
79 | ||
80 | inline std::tm to_tm(decomposed_time const& t) | |
81 | { | |
82 | std::tm res = {}; | |
83 | res.tm_year = static_cast< int >(t.year) - 1900; | |
84 | res.tm_mon = t.month - 1; | |
85 | res.tm_mday = t.day; | |
86 | res.tm_hour = t.hours; | |
87 | res.tm_min = t.minutes; | |
88 | res.tm_sec = t.seconds; | |
89 | res.tm_wday = t.week_day(); | |
90 | res.tm_yday = t.year_day(); | |
91 | res.tm_isdst = -1; | |
92 | ||
93 | return res; | |
94 | } | |
95 | ||
96 | template< typename T > | |
97 | struct decomposed_time_wrapper : | |
98 | public boost::log::aux::decomposed_time | |
99 | { | |
100 | typedef boost::log::aux::decomposed_time base_type; | |
101 | typedef T value_type; | |
102 | value_type m_time; | |
103 | ||
104 | BOOST_DEFAULTED_FUNCTION(decomposed_time_wrapper(), {}) | |
105 | ||
106 | explicit decomposed_time_wrapper(value_type const& time) : m_time(time) | |
107 | { | |
108 | } | |
109 | }; | |
110 | ||
111 | template< typename CharT > | |
112 | BOOST_LOG_API void put_integer(boost::log::aux::basic_ostringstreambuf< CharT >& strbuf, uint32_t value, unsigned int width, CharT fill_char); | |
113 | ||
114 | template< typename T, typename CharT > | |
115 | class date_time_formatter | |
116 | { | |
117 | BOOST_COPYABLE_AND_MOVABLE_ALT(date_time_formatter) | |
118 | ||
119 | protected: | |
120 | // Note: This typedef is needed to work around MSVC 2012 crappy name lookup in the derived classes | |
121 | typedef date_time_formatter date_time_formatter_; | |
122 | ||
123 | public: | |
124 | typedef void result_type; | |
125 | typedef T value_type; | |
126 | typedef CharT char_type; | |
127 | typedef std::basic_string< char_type > string_type; | |
128 | typedef basic_formatting_ostream< char_type > stream_type; | |
129 | ||
130 | struct context | |
131 | { | |
132 | date_time_formatter const& self; | |
133 | stream_type& strm; | |
134 | value_type const& value; | |
135 | unsigned int literal_index, literal_pos; | |
136 | ||
137 | context(date_time_formatter const& self_, stream_type& strm_, value_type const& value_) : | |
138 | self(self_), | |
139 | strm(strm_), | |
140 | value(value_), | |
141 | literal_index(0), | |
142 | literal_pos(0) | |
143 | { | |
144 | } | |
145 | ||
146 | BOOST_DELETED_FUNCTION(context(context const&)) | |
147 | BOOST_DELETED_FUNCTION(context& operator=(context const&)) | |
148 | }; | |
149 | ||
150 | private: | |
151 | typedef void (*formatter_type)(context&); | |
152 | typedef std::vector< formatter_type > formatters; | |
153 | typedef std::vector< unsigned int > literal_lens; | |
154 | ||
155 | protected: | |
156 | formatters m_formatters; | |
157 | literal_lens m_literal_lens; | |
158 | string_type m_literal_chars; | |
159 | ||
160 | public: | |
161 | BOOST_DEFAULTED_FUNCTION(date_time_formatter(), {}) | |
162 | date_time_formatter(date_time_formatter const& that) : | |
163 | m_formatters(that.m_formatters), | |
164 | m_literal_lens(that.m_literal_lens), | |
165 | m_literal_chars(that.m_literal_chars) | |
166 | { | |
167 | } | |
168 | date_time_formatter(BOOST_RV_REF(date_time_formatter) that) BOOST_NOEXCEPT | |
169 | { | |
170 | this->swap(static_cast< date_time_formatter& >(that)); | |
171 | } | |
172 | ||
173 | date_time_formatter& operator= (date_time_formatter that) BOOST_NOEXCEPT | |
174 | { | |
175 | this->swap(that); | |
176 | return *this; | |
177 | } | |
178 | ||
179 | result_type operator() (stream_type& strm, value_type const& value) const | |
180 | { | |
181 | // Some formatters will put characters directly to the underlying string, so we have to flush stream buffers before formatting | |
182 | strm.flush(); | |
183 | context ctx(*this, strm, value); | |
184 | for (typename formatters::const_iterator it = m_formatters.begin(), end = m_formatters.end(); strm.good() && it != end; ++it) | |
185 | { | |
186 | (*it)(ctx); | |
187 | } | |
188 | } | |
189 | ||
190 | void add_formatter(formatter_type fun) | |
191 | { | |
192 | m_formatters.push_back(fun); | |
193 | } | |
194 | ||
195 | void add_literal(iterator_range< const char_type* > const& lit) | |
196 | { | |
197 | m_literal_chars.append(lit.begin(), lit.end()); | |
198 | m_literal_lens.push_back(static_cast< unsigned int >(lit.size())); | |
199 | m_formatters.push_back(&date_time_formatter_::format_literal); | |
200 | } | |
201 | ||
202 | void swap(date_time_formatter& that) BOOST_NOEXCEPT | |
203 | { | |
204 | m_formatters.swap(that.m_formatters); | |
205 | m_literal_lens.swap(that.m_literal_lens); | |
206 | m_literal_chars.swap(that.m_literal_chars); | |
207 | } | |
208 | ||
209 | public: | |
210 | template< char FormatCharV > | |
211 | static void format_through_locale(context& ctx) | |
212 | { | |
213 | typedef std::time_put< char_type > facet_type; | |
214 | typedef typename facet_type::iter_type iter_type; | |
215 | std::tm t = to_tm(static_cast< decomposed_time const& >(ctx.value)); | |
216 | std::use_facet< facet_type >(ctx.strm.getloc()).put(iter_type(ctx.strm.stream()), ctx.strm.stream(), ' ', &t, FormatCharV); | |
217 | ctx.strm.flush(); | |
218 | } | |
219 | ||
220 | static void format_full_year(context& ctx) | |
221 | { | |
222 | (put_integer)(*ctx.strm.rdbuf(), ctx.value.year, 4, static_cast< char_type >('0')); | |
223 | } | |
224 | ||
225 | static void format_short_year(context& ctx) | |
226 | { | |
227 | (put_integer)(*ctx.strm.rdbuf(), ctx.value.year % 100u, 2, static_cast< char_type >('0')); | |
228 | } | |
229 | ||
230 | static void format_numeric_month(context& ctx) | |
231 | { | |
232 | (put_integer)(*ctx.strm.rdbuf(), ctx.value.month, 2, static_cast< char_type >('0')); | |
233 | } | |
234 | ||
235 | template< char_type FillCharV > | |
236 | static void format_month_day(context& ctx) | |
237 | { | |
238 | (put_integer)(*ctx.strm.rdbuf(), ctx.value.day, 2, static_cast< char_type >(FillCharV)); | |
239 | } | |
240 | ||
241 | static void format_week_day(context& ctx) | |
242 | { | |
243 | (put_integer)(*ctx.strm.rdbuf(), static_cast< decomposed_time const& >(ctx.value).week_day(), 1, static_cast< char_type >('0')); | |
244 | } | |
245 | ||
246 | template< char_type FillCharV > | |
247 | static void format_hours(context& ctx) | |
248 | { | |
249 | (put_integer)(*ctx.strm.rdbuf(), ctx.value.hours, 2, static_cast< char_type >(FillCharV)); | |
250 | } | |
251 | ||
252 | template< char_type FillCharV > | |
253 | static void format_hours_12(context& ctx) | |
254 | { | |
255 | (put_integer)(*ctx.strm.rdbuf(), ctx.value.hours % 12u + 1u, 2, static_cast< char_type >(FillCharV)); | |
256 | } | |
257 | ||
258 | static void format_minutes(context& ctx) | |
259 | { | |
260 | (put_integer)(*ctx.strm.rdbuf(), ctx.value.minutes, 2, static_cast< char_type >('0')); | |
261 | } | |
262 | ||
263 | static void format_seconds(context& ctx) | |
264 | { | |
265 | (put_integer)(*ctx.strm.rdbuf(), ctx.value.seconds, 2, static_cast< char_type >('0')); | |
266 | } | |
267 | ||
268 | static void format_fractional_seconds(context& ctx) | |
269 | { | |
270 | (put_integer)(*ctx.strm.rdbuf(), ctx.value.subseconds, decomposed_time::subseconds_digits10, static_cast< char_type >('0')); | |
271 | } | |
272 | ||
273 | template< bool UpperCaseV > | |
274 | static void format_am_pm(context& ctx) | |
275 | { | |
276 | static const char_type am[] = { static_cast< char_type >(UpperCaseV ? 'A' : 'a'), static_cast< char_type >(UpperCaseV ? 'M' : 'm'), static_cast< char_type >(0) }; | |
277 | static const char_type pm[] = { static_cast< char_type >(UpperCaseV ? 'P' : 'p'), static_cast< char_type >(UpperCaseV ? 'M' : 'm'), static_cast< char_type >(0) }; | |
278 | ||
279 | ctx.strm.rdbuf()->append(((static_cast< decomposed_time const& >(ctx.value).hours > 11) ? pm : am), 2u); | |
280 | } | |
281 | ||
282 | template< bool DisplayPositiveV > | |
283 | static void format_sign(context& ctx) | |
284 | { | |
285 | if (static_cast< decomposed_time const& >(ctx.value).negative) | |
286 | ctx.strm.rdbuf()->push_back('-'); | |
287 | else if (DisplayPositiveV) | |
288 | ctx.strm.rdbuf()->push_back('+'); | |
289 | } | |
290 | ||
291 | private: | |
292 | static void format_literal(context& ctx) | |
293 | { | |
294 | unsigned int len = ctx.self.m_literal_lens[ctx.literal_index], pos = ctx.literal_pos; | |
295 | ++ctx.literal_index; | |
296 | ctx.literal_pos += len; | |
297 | const char_type* lit = ctx.self.m_literal_chars.c_str(); | |
298 | ctx.strm.rdbuf()->append(lit + pos, len); | |
299 | } | |
300 | }; | |
301 | ||
302 | template< typename FormatterT, typename CharT > | |
303 | class decomposed_time_formatter_builder : | |
304 | public date_time_format_parser_callback< CharT > | |
305 | { | |
306 | public: | |
307 | typedef date_time_format_parser_callback< CharT > base_type; | |
308 | typedef typename base_type::char_type char_type; | |
309 | typedef FormatterT formatter_type; | |
310 | typedef typename formatter_type::value_type value_type; | |
311 | typedef typename formatter_type::stream_type stream_type; | |
312 | typedef typename stream_type::string_type string_type; | |
313 | ||
314 | protected: | |
315 | formatter_type& m_formatter; | |
316 | ||
317 | public: | |
318 | explicit decomposed_time_formatter_builder(formatter_type& fmt) : m_formatter(fmt) | |
319 | { | |
320 | } | |
321 | ||
322 | void on_literal(iterator_range< const char_type* > const& lit) | |
323 | { | |
324 | m_formatter.add_literal(lit); | |
325 | } | |
326 | ||
327 | void on_short_year() | |
328 | { | |
329 | m_formatter.add_formatter(&formatter_type::format_short_year); | |
330 | } | |
331 | ||
332 | void on_full_year() | |
333 | { | |
334 | m_formatter.add_formatter(&formatter_type::format_full_year); | |
335 | } | |
336 | ||
337 | void on_numeric_month() | |
338 | { | |
339 | m_formatter.add_formatter(&formatter_type::format_numeric_month); | |
340 | } | |
341 | ||
342 | void on_short_month() | |
343 | { | |
344 | m_formatter.add_formatter(&formatter_type::BOOST_NESTED_TEMPLATE format_through_locale< 'b' >); | |
345 | } | |
346 | ||
347 | void on_full_month() | |
348 | { | |
349 | m_formatter.add_formatter(&formatter_type::BOOST_NESTED_TEMPLATE format_through_locale< 'B' >); | |
350 | } | |
351 | ||
352 | void on_month_day(bool leading_zero) | |
353 | { | |
354 | if (leading_zero) | |
355 | m_formatter.add_formatter(&formatter_type::BOOST_NESTED_TEMPLATE format_month_day< '0' >); | |
356 | else | |
357 | m_formatter.add_formatter(&formatter_type::BOOST_NESTED_TEMPLATE format_month_day< ' ' >); | |
358 | } | |
359 | ||
360 | void on_numeric_week_day() | |
361 | { | |
362 | m_formatter.add_formatter(&formatter_type::format_week_day); | |
363 | } | |
364 | ||
365 | void on_short_week_day() | |
366 | { | |
367 | m_formatter.add_formatter(&formatter_type::BOOST_NESTED_TEMPLATE format_through_locale< 'a' >); | |
368 | } | |
369 | ||
370 | void on_full_week_day() | |
371 | { | |
372 | m_formatter.add_formatter(&formatter_type::BOOST_NESTED_TEMPLATE format_through_locale< 'A' >); | |
373 | } | |
374 | ||
375 | void on_hours(bool leading_zero) | |
376 | { | |
377 | if (leading_zero) | |
378 | m_formatter.add_formatter(&formatter_type::BOOST_NESTED_TEMPLATE format_hours< '0' >); | |
379 | else | |
380 | m_formatter.add_formatter(&formatter_type::BOOST_NESTED_TEMPLATE format_hours< ' ' >); | |
381 | } | |
382 | ||
383 | void on_hours_12(bool leading_zero) | |
384 | { | |
385 | if (leading_zero) | |
386 | m_formatter.add_formatter(&formatter_type::BOOST_NESTED_TEMPLATE format_hours_12< '0' >); | |
387 | else | |
388 | m_formatter.add_formatter(&formatter_type::BOOST_NESTED_TEMPLATE format_hours_12< ' ' >); | |
389 | } | |
390 | ||
391 | void on_minutes() | |
392 | { | |
393 | m_formatter.add_formatter(&formatter_type::format_minutes); | |
394 | } | |
395 | ||
396 | void on_seconds() | |
397 | { | |
398 | m_formatter.add_formatter(&formatter_type::format_seconds); | |
399 | } | |
400 | ||
401 | void on_fractional_seconds() | |
402 | { | |
403 | m_formatter.add_formatter(&formatter_type::format_fractional_seconds); | |
404 | } | |
405 | ||
406 | void on_am_pm(bool upper_case) | |
407 | { | |
408 | if (upper_case) | |
409 | m_formatter.add_formatter(&formatter_type::BOOST_NESTED_TEMPLATE format_am_pm< true >); | |
410 | else | |
411 | m_formatter.add_formatter(&formatter_type::BOOST_NESTED_TEMPLATE format_am_pm< false >); | |
412 | } | |
413 | ||
414 | void on_duration_sign(bool display_positive) | |
415 | { | |
416 | if (display_positive) | |
417 | m_formatter.add_formatter(&formatter_type::BOOST_NESTED_TEMPLATE format_sign< true >); | |
418 | else | |
419 | m_formatter.add_formatter(&formatter_type::BOOST_NESTED_TEMPLATE format_sign< false >); | |
420 | } | |
421 | ||
422 | void on_iso_time_zone() | |
423 | { | |
424 | } | |
425 | ||
426 | void on_extended_iso_time_zone() | |
427 | { | |
428 | } | |
429 | }; | |
430 | ||
431 | } // namespace aux | |
432 | ||
433 | BOOST_LOG_CLOSE_NAMESPACE // namespace log | |
434 | ||
435 | } // namespace boost | |
436 | ||
437 | #include <boost/log/detail/footer.hpp> | |
438 | ||
439 | #endif // BOOST_LOG_DETAIL_DECOMPOSED_TIME_HPP_INCLUDED_ |