// (C) Copyright Howard Hinnant
// (C) Copyright 2011 Vicente J. Botet Escriba
// Use, modification and distribution are subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt).
//
/**
* Duration formatting facet for output.
*/
#ifndef BOOST_CHRONO_IO_TIME_POINT_PUT_HPP
#define BOOST_CHRONO_IO_TIME_POINT_PUT_HPP
#include <boost/chrono/config.hpp>
#include <boost/chrono/io/time_point_units.hpp>
#include <boost/chrono/io/duration_put.hpp>
#include <boost/assert.hpp>
#include <locale>
namespace boost
{
namespace chrono
{
/**
* @tparam ChatT a character type
* @tparam OutputIterator a model of @c OutputIterator
*
* The @c time_point_put facet provides facilities for formatted output of @c time_point values.
* The member function of @c time_point_put take a @c time_point and format it into character string representation.
*
*/
template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> >
class time_point_put: public std::locale::facet
{
public:
/**
* Type of character the facet is instantiated on.
*/
typedef CharT char_type;
/**
* Type of character string passed to member functions.
*/
typedef std::basic_string<CharT> string_type;
/**
* Type of iterator used to write in the character buffer.
*/
typedef OutputIterator iter_type;
/**
* Construct a time_point_put facet.
* @param refs
* @Effects Construct a time_point_put facet.
* If the @c refs argument is @c 0 then destruction of the object is
* delegated to the @c locale, or locales, containing it. This allows
* the user to ignore lifetime management issues. On the other had,
* if @c refs is @c 1 then the object must be explicitly deleted;
* the @c locale will not do so. In this case, the object can be
* maintained across the lifetime of multiple locales.
*/
explicit time_point_put(size_t refs = 0) :
std::locale::facet(refs)
{
}
/**
* @param i an output stream iterator
* @param ios a reference to a ios_base
* @param fill the character used as filler
* @param tp the @c time_point
* @param pattern begin of the formatting pattern
* @param pat_end end of the formatting pattern
*
* @Effects Steps through the sequence from @c pattern to @c pat_end,
* identifying characters that are part of a pattern sequence. Each character
* that is not part of a pattern sequence is written to @c s immediately, and
* each pattern sequence, as it is identified, results in a call to
* @c put_duration or @c put_epoch;
* thus, pattern elements and other characters are interleaved in the output
* in the order in which they appear in the pattern. Pattern sequences are
* identified by converting each character @c c to a @c char value as if by
* @c ct.narrow(c,0), where @c ct is a reference to @c ctype<charT> obtained from
* @c ios.getloc(). The first character of each sequence is equal to @c '%',
* followed by a pattern specifier character @c spec, which can be @c 'd' for
* the duration value or @c 'e' for the epoch.
* For each valid pattern sequence identified, calls
* <c>put_duration(s, ios, fill, tp.time_since_epoch())</c> or <c>put_epoch(s, ios)</c>.
*
* @Returns An iterator pointing immediately after the last character produced.
*/
template <class Clock, class Duration>
iter_type put(iter_type i, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp, const CharT* pattern,
const CharT* pat_end) const
{
if (std::has_facet<time_point_units<CharT> >(ios.getloc()))
{
time_point_units<CharT> const &facet =
std::use_facet<time_point_units<CharT> >(ios.getloc());
return put(facet, i, ios, fill, tp, pattern, pat_end);
}
else
{
time_point_units_default<CharT> facet;
return put(facet, i, ios, fill, tp, pattern, pat_end);
}
}
template <class Clock, class Duration>
iter_type put(time_point_units<CharT> const& units_facet, iter_type s, std::ios_base& ios, char_type fill,
time_point<Clock, Duration> const& tp, const CharT* pattern, const CharT* pat_end) const
{
const std::ctype<char_type>& ct = std::use_facet<std::ctype<char_type> >(ios.getloc());
for (; pattern != pat_end; ++pattern)
{
if (ct.narrow(*pattern, 0) == '%')
{
if (++pattern == pat_end)
{
*s++ = pattern[-1];
break;
}
char fmt = ct.narrow(*pattern, 0);
switch (fmt)
{
case 'd':
{
s = put_duration(s, ios, fill, tp.time_since_epoch());
break;
}
case 'e':
{
s = put_epoch<Clock> (units_facet, s, ios);
break;
}
default:
BOOST_ASSERT(false && "Boost::Chrono internal error.");
break;
}
}
else
*s++ = *pattern;
}
return s;
}
/**
* @param i an output stream iterator
* @param ios a reference to a ios_base
* @param fill the character used as filler
* @param tp the @c time_point
* @param pattern begin of the formatting pattern
* @param pat_end end of the formatting pattern
*
* @Effects Stores the time_point pattern from the @c time_point_unit facet in let say @c str. Last as if
* @code
* return put(s, ios, dill, tp, str.data(), str.data() + str.size());
* @endcode
* @Returns An iterator pointing immediately after the last character produced.
*/
template <class Clock, class Duration>
iter_type put(iter_type i, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp) const
{
if (std::has_facet<time_point_units<CharT> >(ios.getloc()))
{
time_point_units<CharT> const &facet =
std::use_facet<time_point_units<CharT> >(ios.getloc());
std::basic_string<CharT> str = facet.get_pattern();
return put(facet, i, ios, fill, tp, str.data(), str.data() + str.size());
}
else
{
time_point_units_default<CharT> facet;
std::basic_string<CharT> str = facet.get_pattern();
return put(facet, i, ios, fill, tp, str.data(), str.data() + str.size());
}
}
/**
* @param i an output stream iterator
* @param ios a reference to a ios_base
* @param fill the character used as filler
* @param d the @c duration
* @Effects As if <c>facet.put(s, ios, fill, d)</c> where facet is the @c duration_put<CharT> facet associated
* to the @c ios or a new instance of @c duration_put<CharT>.
* @Returns An iterator pointing immediately after the last character produced.
*/
template <typename Rep, typename Period>
iter_type put_duration(iter_type i, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const
{
if (std::has_facet<duration_put<CharT> >(ios.getloc()))
{
duration_put<CharT> const &facet = std::use_facet<duration_put<CharT> >(ios.getloc());
return facet.put(i, ios, fill, d);
}
else
{
duration_put<CharT> facet;
return facet.put(i, ios, fill, d);
}
}
/**
*
* @param i an output stream iterator
* @param ios a reference to a ios_base
* @Effects As if
* @code
* string_type str = facet.template get_epoch<Clock>();
* s=std::copy(str.begin(), str.end(), s);
* @endcode
* where facet is the @c time_point_units<CharT> facet associated
* to the @c ios or a new instance of @c time_point_units_default<CharT>.
* @Returns s, iterator pointing immediately after the last character produced.
*/
template <typename Clock>
iter_type put_epoch(iter_type i, std::ios_base& os) const
{
if (std::has_facet<time_point_units<CharT> >(os.getloc()))
{
time_point_units<CharT> const &facet = std::use_facet<time_point_units<CharT> >(os.getloc());
return put_epoch<Clock> (facet, i, os);
}
else
{
time_point_units_default<CharT> facet;
return put_epoch<Clock> (facet, i, os);
}
}
template <typename Clock>
iter_type put_epoch(time_point_units<CharT> const& facet, iter_type s, std::ios_base&) const
{
string_type str = facet.template get_epoch<Clock>();
s= std::copy(str.begin(), str.end(), s);
return s;
}
/**
* Unique identifier for this type of facet.
*/
static std::locale::id id;
/**
* @Effects Destroy the facet
*/
~time_point_put()
{
}
};
template <class CharT, class OutputIterator>
std::locale::id time_point_put<CharT, OutputIterator>::id;
} // chrono
} // boost
#endif // header