void callback(std::ios_base::event ev, std::ios_base& strm, int idx) { if (ev == std::ios_base::erase_event) { try { delete static_cast<NewFormat*>(strm.pword(idx)); strm.pword(idx) = 0; } catch (...) { } } else if (ev == std::ios_base::copyfmt_event) { NewFormat* old(static_cast<NewFormat*>(strm.pword(idx))); if (old != 0) { try { strm.pword(idx) = new NewFormat(*old); } catch (std::bad_alloc&) { } } } }
void replace_pword(std::ios_base& iob, int idx, const T& x) { iob.register_callback(callback<NewFormat>, idx); NewFormat* new_format(new NewFormat(x)); OldFormat* old_format(static_cast<OldFormat*>(iob.pword(idx))); iob.pword(idx) = new_format; delete old_format; }
// Stream format gets copied or destroyed static void my_ios_callback(std::ios_base::event ev, std::ios_base & s, int i) { print_context *p = static_cast<print_context *>(s.pword(i)); if (ev == std::ios_base::erase_event) { delete p; s.pword(i) = nullptr; } else if (ev == std::ios_base::copyfmt_event && p != nullptr) s.pword(i) = p->duplicate(); }
void cleanup(std::ios_base::event evt, std::ios_base& str, int idx) { if (str.iword(separatorEnabled()) && evt == std::ios_base::erase_event) { void*& p = str.pword(idx); delete static_cast<std::string*>(p); str.iword(separatorEnabled()) = false; } }
OutItrT put(OutItrT a_next, std::ios_base& a_ios, char_type a_fill, const time_type& a_time) const { if (a_time.is_special()) { return do_put_special(a_next, a_ios, a_fill, a_time.date().as_special()); } string_type format(m_format); string_type frac_str; if (format.find(seconds_with_fractional_seconds_format)) { // replace %s with %S.nnn frac_str = fractional_seconds_as_string(a_time.time_of_day(), false); char_type sep = std::use_facet<std::numpunct<char_type> >(a_ios.getloc()).decimal_point(); string_type replace_string(seconds_format); replace_string += sep; replace_string += frac_str; boost::algorithm::replace_all(format, seconds_with_fractional_seconds_format, replace_string); } if (format.find(fractional_seconds_format)) { // replace %f with nnnnnnn if (!frac_str.size()) { frac_str = fractional_seconds_as_string(a_time.time_of_day(), false); } boost::algorithm::replace_all(format, fractional_seconds_format, frac_str); } if (format.find(fractional_seconds_or_none_format)) { // replace %F with nnnnnnn or nothing if fs == 0 frac_str = fractional_seconds_as_string(a_time.time_of_day(), true); if (frac_str.size()) { char_type sep = std::use_facet<std::numpunct<char_type> >(a_ios.getloc()).decimal_point(); string_type replace_string; replace_string += sep; replace_string += frac_str; boost::algorithm::replace_all(format, fractional_seconds_or_none_format, replace_string); } else { boost::algorithm::erase_all(format, fractional_seconds_or_none_format); } } return do_put_tm(a_next, a_ios, a_fill, to_tm(a_time), format); }
format_parser::format_parser(std::ios_base &ios,void *cookie,void (*imbuer)(void *,std::locale const &)) : ios_(ios), d(new data) { d->position=std::numeric_limits<unsigned>::max(); d->precision=ios.precision(); d->flags = ios.flags(); d->info=ios_info::get(ios); d->saved_locale = ios.getloc(); d->restore_locale=false; d->cookie = cookie; d->imbuer = imbuer; }
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); } }
bool logstream_base::set_stream_state(std::ios_base& dest, int& dstchar) { std::ios_base::fmtflags setval = initset.flags(); std::ios_base::fmtflags clrval = initclear.flags(); std::ios_base::fmtflags mask = setval ^ (~clrval); dest.setf(clrval, mask); if (initset.precision() == initclear.precision()) { dest.precision(initset.precision()); } if (initset.width() == initclear.width()) { dest.width(initset.width()); } dstchar = fillchar; return fillset; }
iter_type get_duration(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err, duration<Rep, Period>& d) const { if (std::has_facet<duration_get<CharT> >(is.getloc())) { duration_get<CharT> const &facet = std::use_facet<duration_get<CharT> >(is.getloc()); return get_duration(facet, i, e, is, err, d); } else { duration_get<CharT> facet; return get_duration(facet, i, e, is, err, d); } }
iter_type put_unit(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const { if (std::has_facet<duration_units<CharT> >(ios.getloc())) { duration_units<CharT> const&facet = std::use_facet<duration_units<CharT> >( ios.getloc()); return put_unit(facet, s, ios, fill, d); } else { duration_units_default<CharT> facet; return put_unit(facet, s, ios, fill, d); } }
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); } }
// Set print_context associated with stream, retain options static void set_print_context(std::ios_base & s, const print_context & c) { int i = my_ios_index(); long flags = s.iword(i); if (!(flags & callback_registered)) { s.register_callback(my_ios_callback, i); s.iword(i) = flags | callback_registered; } print_context *p = static_cast<print_context *>(s.pword(i)); unsigned options = p ? p->options : c.options; delete p; p = c.duplicate(); p->options = options; s.pword(i) = p; }
void LocaleUtils::CLocaleScope::set(std::ios_base &baseStream) { assert(orgLocale_ == NULL); orgLocale_ = new (static_cast<void*>(&orgLocaleStorage_)) std::locale( baseStream.imbue(getCLocale())); baseStream_ = &baseStream; }
iter_type put(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const { if (std::has_facet<duration_units<CharT> >(ios.getloc())) { duration_units<CharT> const&facet = std::use_facet<duration_units<CharT> >( ios.getloc()); std::basic_string<CharT> str = facet.get_pattern(); return put(facet, s, ios, fill, d, str.data(), str.data() + str.size()); } else { duration_units_default<CharT> facet; std::basic_string<CharT> str = facet.get_pattern(); return put(facet, s, ios, fill, d, str.data(), str.data() + str.size()); } }
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()); } }
iter_type put_unit(duration_units<CharT> const& facet, iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const { if (facet.template is_named_unit<Period>()) { string_type str = facet.get_unit(get_duration_style(ios), d); s=std::copy(str.begin(), str.end(), s); } else { *s++ = CharT('['); std::use_facet<std::num_put<CharT, iter_type> >(ios.getloc()).put(s, ios, fill, Period::num); *s++ = CharT('/'); std::use_facet<std::num_put<CharT, iter_type> >(ios.getloc()).put(s, ios, fill, Period::den); *s++ = CharT(']'); string_type str = facet.get_n_d_unit(get_duration_style(ios), d); s=std::copy(str.begin(), str.end(), s); } return s; }
InItrT get(InItrT& from, InItrT& to, std::ios_base& a_ios, duration_type& dd) const { // skip leading whitespace while(std::isspace(*from) && from != to) { ++from; } /* num_get.get() will always consume the first character if it * is a sign indicator (+/-). Special value strings may begin * with one of these signs so we'll need a copy of it * in case num_get.get() fails. */ char_type c = '\0'; // TODO Are these characters somewhere in the locale? if(*from == '-' || *from == '+') { c = *from; } typedef std::num_get<CharT, InItrT> num_get; typename duration_type::duration_rep_type val = 0; std::ios_base::iostate err = std::ios_base::goodbit; if (std::has_facet<num_get>(a_ios.getloc())) { from = std::use_facet<num_get>(a_ios.getloc()).get(from, to, a_ios, err, val); } else { num_get* ng = new num_get(); std::locale l = std::locale(a_ios.getloc(), ng); a_ios.imbue(l); from = ng->get(from, to, a_ios, err, val); } if(err & std::ios_base::failbit) { typedef typename special_values_parser_type::match_results match_results; match_results mr; if(c == '-' || c == '+') { // was the first character consumed? mr.cache += c; } m_sv_parser.match(from, to, mr); if(mr.current_match == match_results::PARSE_ERROR) { boost::throw_exception(std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'")); BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(return from); // should never reach } dd = duration_type(static_cast<special_values>(mr.current_match)); }
InputIterator get( iter_type b, iter_type e, std::ios_base& iob, std::ios_base::iostate& err, std::tm* tm, const char_type* fmtb, const char_type* fmte) const { const std::ctype<char_type>& ct = std::use_facet<std::ctype<char_type> >(iob.getloc()); err = std::ios_base::goodbit; while (fmtb != fmte && err == std::ios_base::goodbit) { if (b == e) { err = std::ios_base::failbit; break; } if (ct.narrow(*fmtb, 0) == '%') { if (++fmtb == fmte) { err = std::ios_base::failbit; break; } char cmd = ct.narrow(*fmtb, 0); char opt = '\0'; if (cmd == 'E' || cmd == '0') { if (++fmtb == fmte) { err = std::ios_base::failbit; break; } opt = cmd; cmd = ct.narrow(*fmtb, 0); } b = get(b, e, iob, err, tm, cmd, opt); ++fmtb; } else if (ct.is(std::ctype_base::space, *fmtb)) { for (++fmtb; fmtb != fmte && ct.is(std::ctype_base::space, *fmtb); ++fmtb) ; for ( ; b != e && ct.is(std::ctype_base::space, *b); ++b) ; } else if (ct.toupper(*b) == ct.toupper(*fmtb)) { ++b; ++fmtb; } else err = std::ios_base::failbit; } if (b == e) err |= std::ios_base::eofbit; return b; }
void PdfLocaleImbue(std::ios_base& s) { #if USE_CXX_LOCALE static const std::locale cachedLocale( PdfIOLocale ); try { s.imbue( cachedLocale ); } catch (const std::runtime_error & e) { std::ostringstream s; s << "Failed to set safe locale on stream being used for PDF I/O."; s << "Locale set was: \"" << PdfIOLocale << "\"."; s << "Error reported by STL std::locale: \"" << e.what() << "\""; // The info string is copied by PdfError so we're ok to just: PODOFO_RAISE_ERROR_INFO( ePdfError_InvalidDeviceOperation, s.str().c_str() ); } #endif }
void f3(std::ios_base::event ev, std::ios_base& stream, int index) { if (ev == std::ios_base::erase_event) { assert(!f1_called); assert(!f2_called); assert(!f3_called); assert(stream.getloc().name() == "C"); assert(index == 6); f3_called = true; } }
void f3(std::ios_base::event ev, std::ios_base& stream, int index) { if (ev == std::ios_base::imbue_event) { assert(!f1_called); assert(!f2_called); assert(!f3_called); assert(stream.getloc().name() == LOCALE_en_US_UTF_8); assert(index == 6); f3_called = true; } }
OutItrT put(OutItrT next, std::ios_base& a_ios, char_type fill_char, const duration_type& dd) const { if (dd.is_special()) { return do_put_special(next, a_ios, fill_char, dd.get_rep().as_special()); } typedef std::num_put<CharT, OutItrT> num_put; if (std::has_facet<num_put>(a_ios.getloc())) { return std::use_facet<num_put>(a_ios.getloc()).put(next, a_ios, fill_char, dd.get_rep().as_number()); } else { num_put* f = new num_put(); std::locale l = std::locale(a_ios.getloc(), f); a_ios.imbue(l); return f->put(next, a_ios, fill_char, dd.get_rep().as_number()); } }
iter_type get_epoch(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err) const { if (std::has_facet<time_point_units<CharT> >(is.getloc())) { time_point_units<CharT> const &facet = std::use_facet<time_point_units<CharT> >(is.getloc()); return get_epoch(facet, i, e, is, err); } else { time_point_units_default<CharT> facet; return get_epoch(facet, i, e, is, err); } }
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); } }
iter_type 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) const { if (std::has_facet<time_point_units<CharT> >(is.getloc())) { time_point_units<CharT> const &facet = std::use_facet<time_point_units<CharT> >(is.getloc()); return get(facet, i, e, is, err, tp, pattern, pat_end); } else { time_point_units_default<CharT> facet; return get(facet, i, e, is, err, tp, pattern, pat_end); } }
void f1(std::ios_base::event ev, std::ios_base& stream, int index) { if (ev == std::ios_base::erase_event) { assert(!f1_called); assert( f2_called); assert(!g1_called); assert(!g2_called); assert(!g3_called); assert(stream.getloc().name() == LOCALE_en_US_UTF_8); assert(index == 4); f1_called = true; } }
void g3(std::ios_base::event ev, std::ios_base& stream, int index) { if (ev == std::ios_base::copyfmt_event) { assert( f1_called); assert( f2_called); assert(!g1_called); assert(!g2_called); assert(!g3_called); assert(stream.getloc().name() == LOCALE_fr_FR_UTF_8); assert(index == 9); g3_called = true; } }
iter_type get(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err, time_point<Clock, Duration> &tp) const { if (std::has_facet<time_point_units<CharT> >(is.getloc())) { time_point_units<CharT> const &facet = std::use_facet<time_point_units<CharT> >(is.getloc()); std::basic_string<CharT> str = facet.get_pattern(); return get(facet, i, e, is, err, tp, str.data(), str.data() + str.size()); } else { time_point_units_default<CharT> facet; std::basic_string<CharT> str = facet.get_pattern(); return get(facet, i, e, is, err, tp, str.data(), str.data() + str.size()); } }
iter_type put(duration_units<CharT> const& units_facet, iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d, 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 'v': { s = put_value(s, ios, fill, d); break; } case 'u': { s = put_unit(units_facet, s, ios, fill, d); break; } default: BOOST_ASSERT(false && "Boost::Chrono internal error."); break; } } else *s++ = *pattern; } return s; }
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: AUTOBOOST_ASSERT(false && "Boost::Chrono internal error."); break; } } else *s++ = *pattern; } return s; }