inline void out_quote(std::basic_ostream<Ch, Tr> &out, const C& data, IsSpecial is_special = IsSpecial(), char quote_char='"', char escape_char='\\') { std::basic_stringstream<Ch, Tr> s; s << data; or_true_for_chars<IsSpecial> needs_quote(quote_char, escape_char, is_special); typedef std::istreambuf_iterator<Ch, Tr> i_iter; typedef std::ostream_iterator<Ch, Tr> o_iter; i_iter i(s), end; bool quote = (std::find_if (i, end, needs_quote) != end); rewind(s); if (quote) { out << quote_char; for (i_iter i(s); i!=end; ++i) { Ch c=*i; if (c == quote_char || c== escape_char) out.put(escape_char); out.put(c); } out << quote_char; } else { // std::copy(i_iter(s),end,o_iter(out)); /* for (i_iter i(s);i!=end;++i) out.put(*i); */ Ch c; while (s.get(c)) out.put(c); } }
void print( std::basic_ostream< Ch, Traits > &_stream, fcppt::container::tree::object< Value > const &_tree, unsigned const _indent ) { for( unsigned index = 0; index < _indent; ++index ) _stream << _stream.widen('\t'); _stream << _tree.value() << _stream.widen('\n'); for( auto child : _tree ) fcppt::container::tree::detail::print( _stream, child, _indent + 1u ); }
void write_json_helper(std::basic_ostream<typename Ptree::char_type> &stream, const Ptree &pt, int indent) { typedef typename Ptree::char_type Ch; typedef typename std::basic_string<Ch> Str; // Value or object or array if (indent > 0 && pt.empty()) { // Write value Str data = create_escapes(pt.template get_own<Str>(), stream.getloc()); stream << Ch('"') << data << Ch('"'); } else if (indent > 0 && pt.count(Str()) == pt.size()) { // Write array stream << Ch('[') << Ch('\n'); typename Ptree::const_iterator it = pt.begin(); for (; it != pt.end(); ++it) { stream << Str(4 * (indent + 1), Ch(' ')); write_json_helper(stream, it->second, indent + 1); if (boost::next(it) != pt.end()) stream << Ch(','); stream << Ch('\n'); } stream << Str(4 * indent, Ch(' ')) << Ch(']'); } else { // Write object stream << Ch('{') << Ch('\n'); typename Ptree::const_iterator it = pt.begin(); for (; it != pt.end(); ++it) { stream << Str(4 * (indent + 1), Ch(' ')); stream << Ch('"') << create_escapes(it->first, stream.getloc()) << Ch('"') << Ch(':'); if (it->second.empty()) stream << Ch(' '); else stream << Ch('\n') << Str(4 * (indent + 1), Ch(' ')); write_json_helper(stream, it->second, indent + 1); if (boost::next(it) != pt.end()) stream << Ch(','); stream << Ch('\n'); } stream << Str(4 * indent, Ch(' ')) << Ch('}'); } }
inline void insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) { enum { chunk_size = 8 }; charT fill_chars[chunk_size]; std::fill_n(fill_chars, static_cast< std::size_t >(chunk_size), os.fill()); for (; n >= chunk_size && os.good(); n -= chunk_size) os.write(fill_chars, static_cast< std::size_t >(chunk_size)); if (n > 0 && os.good()) os.write(fill_chars, n); }
inline void out_string_always_quote(std::basic_ostream<Ch, Tr> &out, S const& s) { out << '"'; for (typename S::const_iterator i = s.begin(), e = s.end(); i!=e; ++i) { char c=*i; if (c == '"' || c== '\\') out.put('\\'); out.put(c); } out << '"'; }
inline void out_always_quote(std::basic_ostream<Ch, Tr> &out, const C& data) { std::basic_stringstream<Ch, Tr> s; s << data; char c; out << '"'; while (s.get(c)) { if (c == '"' || c== '\\') out.put('\\'); out.put(c); } out << '"'; }
void write_ascii(std::basic_ostream<charT, traits>& os) const { typename std::basic_ostream<charT, traits>::fmtflags save = os.flags(); size_t index_size = (size_t)1 << (num_indexed_chars*2); for (size_t i = 0; i != index_size; ++i) { for (index_type j = index[i]; j != index[i+1]; ++j) { addr_type a = addr[j]; os << "[" << a << " " << string->substr(a, num_indexed_chars) << "]"; } os << "\n"; } os.setstate( save ); }
void write(const CharT* s, size_t length) { size_t diff = end_buffer_ - p_; if (diff >= length) { std::memcpy(p_, s, length*sizeof(CharT)); p_ += length; } else { os_->write(begin_buffer_, (p_ - begin_buffer_)); os_->write(s, length); p_ = begin_buffer_; } }
void operator () (T1 x1, T2 x2, T3 x3) const { *stream << x1 << separator << x2 << separator << x3 << '\n'; stream->flush(); }
/// /// Translate message and write to stream \a out, using imbued locale and domain set to the /// stream /// void write(std::basic_ostream<char_type> &out) const { std::locale const &loc = out.getloc(); int id = ios_info::get(out).domain_id(); string_type buffer; out << write(loc,id,buffer); }
basic_csv_ostream<Char, Traits>::basic_csv_ostream (std::basic_ostream<Char, Traits> & os) : os_(os) , delim_(os.widen(COMMA)) , quote_(os.widen(QUOTE)) , first_(true) {}
basic_csv_ostream<Char, Traits>::basic_csv_ostream (std::basic_ostream<Char, Traits> & os, char_type delimiter) : os_(os) , delim_(delimiter) , quote_(os.widen(QUOTE)) , first_(true) {}
void write_info_internal(std::basic_ostream<typename Ptree::char_type> &stream, const Ptree &pt, const std::string &filename) { write_info_helper(stream, pt, -1); if (!stream.good()) throw info_parser_error("write error", filename, 0); }
void write_info_internal(std::basic_ostream<typename Ptree::key_type::value_type> &stream, const Ptree &pt, const std::string &filename, const info_writer_settings<typename Ptree::key_type::value_type> &settings) { write_info_helper(stream, pt, -1, settings); if (!stream.good()) BOOST_PROPERTY_TREE_THROW(info_parser_error("write error", filename, 0)); }
bool validate(std::basic_ostream<Char>& out) const { typename std::basic_ostream<Char>::streampos current = out.tellp(); out.seekp(0, std::ios::end); uint32_t file_size = static_cast<uint32_t>(out.tellp()); out.seekp(current, std::ios::beg); uint32_t supposed_size = data_subchunk.size + sizeof(header_type); if (file_size != supposed_size) { DBGLOG("There is a difference between the wav file size" " and the size of data that is written in the" " header: " << file_size << " != " << supposed_size); return false; } return true; }
void write_json_internal(std::basic_ostream<typename Ptree::char_type> &stream, const Ptree &pt, const std::string &filename) { if (!verify_json(pt, 0)) throw json_parser_error("ptree contains data that cannot be represented in JSON format", filename, 0); write_json_helper(stream, pt, 0); stream << std::endl; if (!stream.good()) throw json_parser_error("write error", filename, 0); }
void write_json_internal(std::basic_ostream<typename Ptree::key_type::value_type> &stream, const Ptree &pt, const std::string &filename, bool pretty) { if (!verify_json(pt, 0)) BOOST_PROPERTY_TREE_THROW(json_parser_error("ptree contains data that cannot be represented in JSON format", filename, 0)); write_json_helper(stream, pt, 0, pretty); stream << std::endl; if (!stream.good()) BOOST_PROPERTY_TREE_THROW(json_parser_error("write error", filename, 0)); }
binary_oarchive_impl( std::basic_ostream<Elem, Tr> & os, unsigned int flags ) : basic_binary_oprimitive<Archive, Elem, Tr>( * os.rdbuf(), 0 != (flags & no_codecvt) ), basic_binary_oarchive<Archive>(flags) { init(flags); }
void put(CharT c) { if (p_ < end_buffer_) { *p_++ = c; } else { os_->write(begin_buffer_, (p_-begin_buffer_)); p_ = begin_buffer_; *p_++ = c; } }
inline void hex_dump(const void* aData, std::size_t aLength, std::basic_ostream<Elem, Traits>& aStream, std::size_t aWidth = 16) { const char* const start = static_cast<const char*>(aData); const char* const end = start + aLength; const char* line = start; while (line != end) { aStream.width(4); aStream.fill('0'); aStream << std::hex << line - start << " : "; std::size_t lineLength = std::min(aWidth, static_cast<std::size_t>(end - line)); for (std::size_t pass = 1; pass <= 2; ++pass) { for (const char* next = line; next != end && next != line + aWidth; ++next) { char ch = *next; switch(pass) { case 1: aStream << (ch < 32 ? '.' : ch); break; case 2: if (next != line) aStream << " "; aStream.width(2); aStream.fill('0'); aStream << std::hex << std::uppercase << static_cast<int>(static_cast<unsigned char>(ch)); break; } } if (pass == 1 && lineLength != aWidth) aStream << std::string(aWidth - lineLength, ' '); aStream << " "; } aStream << std::endl; line = line + lineLength; } }
void escape_char(std::basic_ostream<Char, Traits> &os, Char c, Char delim) { const char escape = '\\'; if(c < 32 || c == 0x7f) { os << escape; switch(c) { case '\0': os << os.widen('0'); break; case '\a': os << os.widen('a'); break; case '\b': os << os.widen('b'); break; case '\f': os << os.widen('f'); break; case '\n': os << os.widen('n'); break; case '\r': os << os.widen('r'); break; case '\t': os << os.widen('t'); break; case '\v': os << os.widen('v'); break; default: os << os.widen('x') << static_cast<unsigned long>(c); } } else if(c == delim || c == escape) { os << escape << c; } else { os << c; } }
inline bool handle_width(std::basic_ostream<CharT, Traits>& o, const T& t) { std::streamsize width = o.width(); if(width == 0) return false; std::basic_ostringstream<CharT, Traits> ss; ss.copyfmt(o); ss.tie(0); ss.width(0); ss << t; o << ss.str(); return true; }
void insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) { const std::size_t size = str.size(); const std::size_t alignment_size = static_cast< std::size_t >(os.width()) - size; const bool align_left = (os.flags() & std::basic_ostream<charT, traits>::adjustfield) == std::basic_ostream<charT, traits>::left; if (!align_left) { detail::insert_fill_chars(os, alignment_size); if (os.good()) os.write(str.data(), size); } else { os.write(str.data(), size); if (os.good()) detail::insert_fill_chars(os, alignment_size); } }
inline void fprint(std::basic_ostream<Elem, Traits>& out, const std::basic_string<Elem, Traits>& str, Args&&... arguments) { if(sizeof...(arguments) < 1) { out << str; return; } auto args = std::make_tuple(std::forward<Args>(arguments)...); string::is_digit cmp; auto&& length = str.size(); auto&& original_width = out.width(); std::ios_base::fmtflags original_format = out.flags(); auto&& original_precision = out.precision(); for(decltype(str.size()) i = 0; i < length; ++i) { auto&& c = str[i]; // doesn't start with { so just print it and continue if(c != out.widen('{')) { out << c; continue; } // at this point, the character c points to { // check if we're done printing if(i + 1 > length) { out << c; break; } // check the next characters auto j = i + 1; unsigned index = 0; decltype(out.width()) width = 0; decltype(out.precision()) precision = 0; auto format = original_format; // escaped character if(str[j] == out.widen('{')) { out << str[i]; i = j; continue; } // now we're at a sane point where we can work with the format string // check if the next character is a digit if(cmp(str[j])) { do { // since it is, multiply the index index = (index * 10) + (str[j++] - out.widen('0')); } while(j < length && cmp(str[j])); } else { // since it isn't a digit, it doesn't match our format string throw std::runtime_error("invalid format string specified"); } // check if alignment argument exists if(str[j] == out.widen(',')) { // check if the next character is valid if(j + 1 < length) { // check if the alignment is left or right if(str[j + 1] == out.widen('-')) { format |= out.left; // increment by two to get to the numerical section j += 2; } else { format |= out.right; ++j; } // check if the next character is a digit if(j < length && cmp(str[j])) { do { // since it is, multiply the width width = (width * 10) + (str[j++] - out.widen('0')); } while(j < length && cmp(str[j])); } else { // invalid format string found throw std::runtime_error("invalid format string specified"); } } } // check if format specifier exists if(str[j] == out.widen(':')) { // check if the character is valid if(j + 1 < length) { auto&& specifier = str[j + 1]; switch(specifier) { case 'F': format |= out.fixed; break; case 'O': format = (format & ~out.basefield) | out.oct; break; case 'x': format = (format & ~out.basefield) | out.hex; break; case 'X': format = (format & ~out.basefield) | out.hex | out.uppercase; break; case 'E': format |= out.scientific | out.uppercase; break; case 'e': format |= out.scientific; break; case 'B': format |= out.boolalpha; break; case 'S': format |= out.showpos; break; default: throw std::runtime_error("no such format specifier found"); break; } j += 2; // handle precision specifier if(j < length && cmp(str[j])) { do { precision = (precision * 10) + (str[j++] - out.widen('0')); } while(j < length && cmp(str[j])); } } } // now that we're done processing, handle the results if(str[j] == out.widen('}')) { out.flags(format); out.width(width); out.precision(precision); detail::index_printer(out, index, args); out.width(original_width); out.flags(original_format); out.precision(original_precision); i = j; } } }
inline void fprint(std::basic_ostream<Char, Trait>& out, const Char* str, Args&&... arguments) { // %[parameter][flags][width][.precision]verb // if it's *n$ instead of %n$ then it'll use the specific parameter number // n starts at 1 to sizeof...(Args) // at the moment I'm too lazy to do * at all. auto&& args = std::make_tuple(std::forward<Args>(arguments)...); stream_state<Char, Trait> original{out}; stream_state<Char, Trait> changed; printer<Char, Trait> func(out); const Char percent = out.widen('%'); const Char zero = out.widen('0'); auto&& loc = out.getloc(); size_t index = 0; size_t position = 0; bool has_positional = false; while(*str != 0) { // not a % if(!Trait::eq(*str, percent)) { out << *str++; continue; } // at this point -- *str == '%' // so just increment it to get to the format-spec ++str; // escaped % if(*str && Trait::eq(*str, percent)) { out << percent; ++str; continue; } // beginning of format-spec changed = original; // check for [parameter], i.e. n$ // or a numeric value for [width] position = parse_integer(str, zero, loc); // check if it's [parameter] rather than [width] if(Trait::eq(*str, out.widen('$'))) { has_positional = true; ++str; } // check for [flags] // they are as follows: // + - equivalent to std::showpos // - - left aligns instead of right align, i.e. std::left // 0 - pad with 0s instead of spaces // '[char] - pad with [char] instead of spaces while(*str) { if(Trait::eq(*str, out.widen('+'))) { changed.flags |= out.showpos; } else if(Trait::eq(*str, out.widen('-'))) { changed.flags |= out.left; } else if(Trait::eq(*str, out.widen('0'))) { changed.fill = out.widen('0'); } else if(Trait::eq(*str, out.widen('\''))) { // the next character is unconditionally the fill character changed.fill = *(++str); } else { // unknown flag, so just exit break; } ++str; } // check for [width] changed.width = parse_integer(str, zero, loc); // check for [precision] if(Trait::eq(*str, out.widen('.'))) { changed.precision = parse_integer(++str, zero, loc); } size_t final_index = has_positional ? position - 1 : index++; // check for verb if(Trait::eq(*str, out.widen('s')) || Trait::eq(*str, out.widen('c'))) { // do nothing since these don't add any extra format specifiers. // many of these are provided as a thin compatibility layer for // the original printf -- albeit strict compatibility is not a requirement here. } else if(Trait::eq(*str, out.widen('f')) || Trait::eq(*str, out.widen('F'))) { changed.flags |= out.fixed; } else if(Trait::eq(*str, out.widen('e'))) { changed.flags |= out.scientific; } else if(Trait::eq(*str, out.widen('E'))) { changed.flags |= out.scientific; changed.flags |= out.uppercase; } else if(Trait::eq(*str, out.widen('g'))) { changed.flags &= ~out.floatfield; } else if(Trait::eq(*str, out.widen('G'))) { changed.flags &= ~out.floatfield; changed.flags |= out.uppercase; } else if(Trait::eq(*str, out.widen('x')) || Trait::eq(*str, out.widen('p'))) { changed.flags |= out.hex; } else if(Trait::eq(*str, out.widen('X'))) { changed.flags |= out.hex; changed.flags |= out.uppercase; } else if(Trait::eq(*str, out.widen('d')) || Trait::eq(*str, out.widen('i')) || Trait::eq(*str, out.widen('u'))) { changed.flags |= out.dec; } else if(Trait::eq(*str, out.widen('o'))) { changed.flags |= out.oct; } else { std::string error = "invalid verb given "; auto narrowed = out.narrow(*str, 0x00); if(narrowed == 0x00) { error.push_back('\''); error.push_back(narrowed); error.push_back('\''); } else { error.append(" (unable to convert to char)"); } throw std::runtime_error(error); } changed.apply(out); apply(args, final_index, func); original.apply(out); ++str; } }
explicit basic_obstream(std::basic_ostream<_CharT, _Traits> &out) : std::basic_ostream<_CharT, _Traits>(out.rdbuf()) { }
void flush() { os_->write(begin_buffer_, (p_ - begin_buffer_)); p_ = begin_buffer_; os_->flush(); }
~buffered_ostream() { os_->write(begin_buffer_, (p_ - begin_buffer_)); os_->flush(); }
typename std::enable_if< mizuiro::color::is_color< Color >::value, std::basic_ostream< Ch, Traits > & >::type operator<<( std::basic_ostream< Ch, Traits > &_stream, Color const &_color ) { _stream << _stream.widen('('); mizuiro::color::for_each_channel( _color, [ &_color, &_stream ]( auto const _channel ) { _stream << static_cast< mizuiro::detail::promote_type< mizuiro::color::types::channel_value< mizuiro::color::format::get< Color >, std::remove_const_t< decltype( _channel ) > > > >( _color.get( _channel ) ) << // FIXME _stream.widen(','); } ); _stream << _stream.widen(')'); return _stream; }
void operator () (T1 x1) const { *stream << x1 << '\n'; stream->flush(); }