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/**
9 * Duration formatting facet for output.
10 */
11#ifndef BOOST_CHRONO_IO_TIME_POINT_PUT_HPP
12#define BOOST_CHRONO_IO_TIME_POINT_PUT_HPP
13
14#include <boost/chrono/config.hpp>
15#include <boost/chrono/io/time_point_units.hpp>
16#include <boost/chrono/io/duration_put.hpp>
17#include <boost/assert.hpp>
18#include <locale>
19
20namespace boost
21{
22 namespace chrono
23 {
24
25 /**
26 * @tparam ChatT a character type
27 * @tparam OutputIterator a model of @c OutputIterator
28 *
29 * The @c time_point_put facet provides facilities for formatted output of @c time_point values.
30 * The member function of @c time_point_put take a @c time_point and format it into character string representation.
31 *
32 */
33 template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> >
34 class time_point_put: public std::locale::facet
35 {
36 public:
37 /**
38 * Type of character the facet is instantiated on.
39 */
40 typedef CharT char_type;
41 /**
42 * Type of character string passed to member functions.
43 */
44 typedef std::basic_string<CharT> string_type;
45 /**
46 * Type of iterator used to write in the character buffer.
47 */
48 typedef OutputIterator iter_type;
49
50 /**
51 * Construct a time_point_put facet.
52 * @param refs
53 * @Effects Construct a time_point_put facet.
54 * If the @c refs argument is @c 0 then destruction of the object is
55 * delegated to the @c locale, or locales, containing it. This allows
56 * the user to ignore lifetime management issues. On the other had,
57 * if @c refs is @c 1 then the object must be explicitly deleted;
58 * the @c locale will not do so. In this case, the object can be
59 * maintained across the lifetime of multiple locales.
60 */
61 explicit time_point_put(size_t refs = 0) :
62 std::locale::facet(refs)
63 {
64 }
65
66 /**
67 * @param i an output stream iterator
68 * @param ios a reference to a ios_base
69 * @param fill the character used as filler
70 * @param tp the @c time_point
71 * @param pattern begin of the formatting pattern
72 * @param pat_end end of the formatting pattern
73 *
74 * @Effects Steps through the sequence from @c pattern to @c pat_end,
75 * identifying characters that are part of a pattern sequence. Each character
76 * that is not part of a pattern sequence is written to @c s immediately, and
77 * each pattern sequence, as it is identified, results in a call to
78 * @c put_duration or @c put_epoch;
79 * thus, pattern elements and other characters are interleaved in the output
80 * in the order in which they appear in the pattern. Pattern sequences are
81 * identified by converting each character @c c to a @c char value as if by
82 * @c ct.narrow(c,0), where @c ct is a reference to @c ctype<charT> obtained from
83 * @c ios.getloc(). The first character of each sequence is equal to @c '%',
84 * followed by a pattern specifier character @c spec, which can be @c 'd' for
85 * the duration value or @c 'e' for the epoch.
86 * For each valid pattern sequence identified, calls
87 * <c>put_duration(s, ios, fill, tp.time_since_epoch())</c> or <c>put_epoch(s, ios)</c>.
88 *
89 * @Returns An iterator pointing immediately after the last character produced.
90 */
91
92 template <class Clock, class Duration>
93 iter_type put(iter_type i, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp, const CharT* pattern,
94 const CharT* pat_end) const
95 {
96 if (std::has_facet<time_point_units<CharT> >(ios.getloc()))
97 {
98 time_point_units<CharT> const &facet =
99 std::use_facet<time_point_units<CharT> >(ios.getloc());
100 return put(facet, i, ios, fill, tp, pattern, pat_end);
101 }
102 else
103 {
104 time_point_units_default<CharT> facet;
105 return put(facet, i, ios, fill, tp, pattern, pat_end);
106 }
107 }
108
109 template <class Clock, class Duration>
110 iter_type put(time_point_units<CharT> const& units_facet, iter_type s, std::ios_base& ios, char_type fill,
111 time_point<Clock, Duration> const& tp, const CharT* pattern, const CharT* pat_end) const
112 {
113
114 const std::ctype<char_type>& ct = std::use_facet<std::ctype<char_type> >(ios.getloc());
115 for (; pattern != pat_end; ++pattern)
116 {
117 if (ct.narrow(*pattern, 0) == '%')
118 {
119 if (++pattern == pat_end)
120 {
121 *s++ = pattern[-1];
122 break;
123 }
124 char fmt = ct.narrow(*pattern, 0);
125 switch (fmt)
126 {
127 case 'd':
128 {
129 s = put_duration(s, ios, fill, tp.time_since_epoch());
130 break;
131 }
132 case 'e':
133 {
134 s = put_epoch<Clock> (units_facet, s, ios);
135 break;
136 }
137 default:
138 BOOST_ASSERT(false && "Boost::Chrono internal error.");
139 break;
140 }
141 }
142 else
143 *s++ = *pattern;
144 }
145 return s;
146 }
147
148 /**
149 * @param i an output stream iterator
150 * @param ios a reference to a ios_base
151 * @param fill the character used as filler
152 * @param tp the @c time_point
153 * @param pattern begin of the formatting pattern
154 * @param pat_end end of the formatting pattern
155 *
156 * @Effects Stores the time_point pattern from the @c time_point_unit facet in let say @c str. Last as if
157 * @code
158 * return put(s, ios, dill, tp, str.data(), str.data() + str.size());
159 * @endcode
160 * @Returns An iterator pointing immediately after the last character produced.
161 */
162 template <class Clock, class Duration>
163 iter_type put(iter_type i, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp) const
164 {
165 if (std::has_facet<time_point_units<CharT> >(ios.getloc()))
166 {
167 time_point_units<CharT> const &facet =
168 std::use_facet<time_point_units<CharT> >(ios.getloc());
169 std::basic_string<CharT> str = facet.get_pattern();
170 return put(facet, i, ios, fill, tp, str.data(), str.data() + str.size());
171 }
172 else
173 {
174 time_point_units_default<CharT> facet;
175 std::basic_string<CharT> str = facet.get_pattern();
176 return put(facet, i, ios, fill, tp, str.data(), str.data() + str.size());
177 }
178 }
179
180 /**
181 * @param i an output stream iterator
182 * @param ios a reference to a ios_base
183 * @param fill the character used as filler
184 * @param d the @c duration
185 * @Effects As if <c>facet.put(s, ios, fill, d)</c> where facet is the @c duration_put<CharT> facet associated
186 * to the @c ios or a new instance of @c duration_put<CharT>.
187 * @Returns An iterator pointing immediately after the last character produced.
188 */
189 template <typename Rep, typename Period>
190 iter_type put_duration(iter_type i, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const
191 {
192 if (std::has_facet<duration_put<CharT> >(ios.getloc()))
193 {
194 duration_put<CharT> const &facet = std::use_facet<duration_put<CharT> >(ios.getloc());
195 return facet.put(i, ios, fill, d);
196 }
197 else
198 {
199 duration_put<CharT> facet;
200 return facet.put(i, ios, fill, d);
201 }
202 }
203
204 /**
205 *
206 * @param i an output stream iterator
207 * @param ios a reference to a ios_base
208 * @Effects As if
209 * @code
210 * string_type str = facet.template get_epoch<Clock>();
211 * s=std::copy(str.begin(), str.end(), s);
212 * @endcode
213 * where facet is the @c time_point_units<CharT> facet associated
214 * to the @c ios or a new instance of @c time_point_units_default<CharT>.
215 * @Returns s, iterator pointing immediately after the last character produced.
216 */
217
218 template <typename Clock>
219 iter_type put_epoch(iter_type i, std::ios_base& os) const
220 {
221 if (std::has_facet<time_point_units<CharT> >(os.getloc()))
222 {
223 time_point_units<CharT> const &facet = std::use_facet<time_point_units<CharT> >(os.getloc());
224 return put_epoch<Clock> (facet, i, os);
225 }
226 else
227 {
228 time_point_units_default<CharT> facet;
229 return put_epoch<Clock> (facet, i, os);
230 }
231 }
232
233 template <typename Clock>
234 iter_type put_epoch(time_point_units<CharT> const& facet, iter_type s, std::ios_base&) const
235 {
236 string_type str = facet.template get_epoch<Clock>();
237 s= std::copy(str.begin(), str.end(), s);
238 return s;
239 }
240
241 /**
242 * Unique identifier for this type of facet.
243 */
244 static std::locale::id id;
245
246 /**
247 * @Effects Destroy the facet
248 */
249 ~time_point_put()
250 {
251 }
252
253 };
254
255 template <class CharT, class OutputIterator>
256 std::locale::id time_point_put<CharT, OutputIterator>::id;
257
258 } // chrono
259} // boost
260
261#endif // header
262

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